summaryrefslogtreecommitdiffstats
path: root/screen.c
diff options
context:
space:
mode:
Diffstat (limited to 'screen.c')
-rw-r--r--screen.c3416
1 files changed, 3416 insertions, 0 deletions
diff --git a/screen.c b/screen.c
new file mode 100644
index 0000000..c3417e3
--- /dev/null
+++ b/screen.c
@@ -0,0 +1,3416 @@
+/* Copyright (c) 2010
+ * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
+ * Sadrul Habib Chowdhury (sadrul@users.sourceforge.net)
+ * Copyright (c) 2008, 2009
+ * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
+ * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
+ * Micah Cowan (micah@cowan.name)
+ * Sadrul Habib Chowdhury (sadrul@users.sourceforge.net)
+ * Copyright (c) 1993-2002, 2003, 2005, 2006, 2007
+ * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
+ * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
+ * Copyright (c) 1987 Oliver Laumann
+#ifdef HAVE_BRAILLE
+ * Modified by:
+ * Authors: Hadi Bargi Rangin bargi@dots.physics.orst.edu
+ * Bill Barry barryb@dots.physics.orst.edu
+ * Randy Lundquist randyl@dots.physics.orst.edu
+ *
+ * Modifications Copyright (c) 1995 by
+ * Science Access Project, Oregon State University.
+#endif
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program (see the file COPYING); if not, see
+ * http://www.gnu.org/licenses/, or contact Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ *
+ ****************************************************************
+ */
+
+#include <sys/types.h>
+#ifdef _AIX
+#include <sys/socket.h>
+#endif
+#include <ctype.h>
+#include <stdbool.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#if defined(__sun)
+# include <limits.h>
+#endif
+
+#ifdef sgi
+# include <sys/sysmacros.h>
+#endif
+
+#include <sys/stat.h>
+#ifndef sun
+# include <sys/ioctl.h>
+#endif
+
+#ifndef SIGINT
+# include <signal.h>
+#endif
+
+#include "config.h"
+
+#ifdef HAVE_STROPTS_H
+# include <sys/stropts.h>
+#endif
+
+#if defined(SYSV) && !defined(ISC)
+# include <sys/utsname.h>
+#endif
+
+#if defined(sequent) || defined(SVR4)
+# include <sys/resource.h>
+#endif /* sequent || SVR4 */
+
+#ifdef ISC
+# include <sys/tty.h>
+# include <sys/sioctl.h>
+# include <sys/pty.h>
+#endif /* ISC */
+
+#if (defined(AUX) || defined(_AUX_SOURCE)) && defined(POSIX)
+# include <compat.h>
+#endif
+#if defined(USE_LOCALE) || defined(ENCODINGS)
+# include <locale.h>
+#endif
+#if defined(HAVE_NL_LANGINFO) && defined(ENCODINGS)
+# include <langinfo.h>
+#endif
+
+#include "screen.h"
+#ifdef HAVE_BRAILLE
+# include "braille.h"
+#endif
+
+#include "patchlevel.h"
+
+/*
+ * At the moment we only need the real password if the
+ * builtin lock is used. Therefore disable SHADOWPW if
+ * we do not really need it (kind of security thing).
+ */
+#ifndef LOCK
+# undef SHADOWPW
+#endif
+
+#include <pwd.h>
+#ifdef SHADOWPW
+# include <shadow.h>
+#endif /* SHADOWPW */
+
+#include "logfile.h" /* islogfile, logfflush, logfopen/logfclose */
+
+#ifdef DEBUG
+FILE *dfp;
+#endif
+
+
+extern char Term[], screenterm[], **environ, Termcap[];
+int force_vt = 1;
+int VBellWait, MsgWait, MsgMinWait, SilenceWait;
+
+extern struct acluser *users;
+extern struct display *displays, *display;
+extern struct LayFuncs MarkLf;
+
+extern int visual_bell;
+#ifdef COPY_PASTE
+extern unsigned char mark_key_tab[];
+#endif
+extern char version[];
+extern char DefaultShell[];
+#ifdef ZMODEM
+extern char *zmodem_sendcmd;
+extern char *zmodem_recvcmd;
+#endif
+extern struct layout *layout_last;
+
+char *ShellProg;
+char *ShellArgs[2];
+
+extern struct NewWindow nwin_undef, nwin_default, nwin_options;
+struct backtick;
+
+static struct passwd *getpwbyname __P((char *, struct passwd *));
+static void SigChldHandler __P((void));
+static sigret_t SigChld __P(SIGPROTOARG);
+static sigret_t SigInt __P(SIGPROTOARG);
+static sigret_t CoreDump __P(SIGPROTOARG);
+static sigret_t FinitHandler __P(SIGPROTOARG);
+static void DoWait __P((void));
+static void serv_read_fn __P((struct event *, char *));
+static void serv_select_fn __P((struct event *, char *));
+static void logflush_fn __P((struct event *, char *));
+static void backtick_filter __P((struct backtick *));
+static void backtick_fn __P((struct event *, char *));
+static char *runbacktick __P((struct backtick *, int *, time_t));
+static int IsSymbol __P((char *, char *));
+static char *ParseChar __P((char *, char *));
+static int ParseEscape __P((char *));
+static char *pad_expand __P((char *, char *, int, int));
+static void SetTtyname __P((bool, struct stat *));
+#ifdef DEBUG
+static void fds __P((void));
+#endif
+
+int nversion; /* numerical version, used for secondary DA */
+
+/* the attacher */
+struct passwd *ppp;
+char *attach_tty;
+/* Indicator whether the current tty exists in another namespace. */
+bool attach_tty_is_in_new_ns = false;
+/* Content of the tty symlink when attach_tty_is_in_new_ns == true. */
+char attach_tty_name_in_ns[MAXPATHLEN];
+int attach_fd = -1;
+char *attach_term;
+char *LoginName;
+struct mode attach_Mode;
+
+char SockPath[MAXPATHLEN + 2 * MAXSTR];
+char *SockName; /* SockName is pointer in SockPath */
+char *SockMatch = NULL; /* session id command line argument */
+int ServerSocket = -1;
+struct event serv_read;
+struct event serv_select;
+struct event logflushev;
+
+char **NewEnv = NULL;
+
+char *RcFileName = NULL;
+char *home;
+
+char *screenlogfile; /* filename layout */
+int log_flush = 10; /* flush interval in seconds */
+int logtstamp_on = 0; /* tstamp disabled */
+char *logtstamp_string; /* stamp layout */
+int logtstamp_after = 120; /* first tstamp after 120s */
+char *hardcopydir = NULL;
+char *BellString;
+char *VisualBellString;
+char *ActivityString;
+#ifdef COPY_PASTE
+char *BufferFile;
+#endif
+#ifdef POW_DETACH
+char *PowDetachString;
+#endif
+char *hstatusstring;
+char *captionstring;
+char *timestring;
+char *wliststr;
+char *wlisttit;
+int auto_detach = 1;
+int iflag, rflag, dflag, lsflag, quietflag, wipeflag, xflag;
+int cmdflag;
+int queryflag = -1;
+int adaptflag;
+
+#ifdef MULTIUSER
+char *multi;
+char *multi_home;
+int multi_uid;
+int own_uid;
+int multiattach;
+int tty_mode;
+int tty_oldmode = -1;
+#endif
+
+char HostName[MAXSTR];
+int MasterPid, PanicPid;
+int real_uid, real_gid, eff_uid, eff_gid;
+int default_startup;
+int ZombieKey_destroy, ZombieKey_resurrect, ZombieKey_onerror;
+char *preselect = NULL; /* only used in Attach() */
+
+#ifdef UTF8
+char *screenencodings;
+#endif
+
+#ifdef DW_CHARS
+int cjkwidth;
+#endif
+
+#ifdef NETHACK
+int nethackflag = 0;
+#endif
+int maxwin;
+
+struct layer *flayer;
+struct win *fore;
+struct win *windows;
+struct win *console_window;
+
+#ifdef BUILTIN_TELNET
+int af;
+#endif
+
+/*
+ * Do this last
+ */
+#include "extern.h"
+
+char strnomem[] = "Out of memory.";
+
+static int InterruptPlease;
+static int GotSigChld;
+
+static int lf_secreopen(name, wantfd, l)
+char *name;
+int wantfd;
+
+struct logfile *l;
+{
+ int got_fd;
+ close(wantfd);
+ if (((got_fd = secopen(name, O_WRONLY | O_CREAT | O_APPEND, 0666)) < 0) || lf_move_fd(got_fd, wantfd) < 0) {
+ logfclose(l);
+ debug1("lf_secreopen: failed for %s\n", name);
+ return -1;
+ }
+ l->st->st_ino = l->st->st_dev = 0;
+ debug2("lf_secreopen: %d = %s\n", wantfd, name);
+ return 0;
+}
+
+/********************************************************************/
+/********************************************************************/
+/********************************************************************/
+
+static struct passwd * getpwbyname(name, ppp)
+char *name;
+
+struct passwd *ppp;
+{
+ int n;
+#ifdef SHADOWPW
+ struct spwd *sss = NULL;
+ static char *spw = NULL;
+#endif
+
+ if (!ppp && !(ppp = getpwnam(name)))
+ return NULL;
+
+ /* Do password sanity check..., allow ##user for SUN_C2 security */
+#ifdef SHADOWPW
+pw_try_again:
+#endif
+ n = 0;
+ if (ppp->pw_passwd[0] == '#' && ppp->pw_passwd[1] == '#' && strcmp(ppp->pw_passwd + 2, ppp->pw_name) == 0)
+ n = 13;
+ for (; n < 13; n++) {
+ char c = ppp->pw_passwd[n];
+ if (!(c == '.' || c == '/' || c == '$' ||
+ (c >= '0' && c <= '9') ||
+ (c >= 'a' && c <= 'z') ||
+ (c >= 'A' && c <= 'Z')))
+ break;
+ }
+
+#ifdef SHADOWPW
+ /* try to determine real password */
+ if (n < 13 && sss == 0) {
+ sss = getspnam(ppp->pw_name);
+ if (sss) {
+ if (spw)
+ free(spw);
+ ppp->pw_passwd = spw = SaveStr(sss->sp_pwdp);
+ endspent(); /* this should delete all buffers ... */
+ goto pw_try_again;
+ }
+ endspent(); /* this should delete all buffers ... */
+ }
+#endif
+ if (n < 13)
+ ppp->pw_passwd = 0;
+#ifdef linux
+ if (ppp->pw_passwd && strlen(ppp->pw_passwd) == 13 + 11)
+ ppp->pw_passwd[13] = 0; /* beware of linux's long passwords */
+#endif
+
+ return ppp;
+}
+
+static char *locale_name(void)
+{
+ static char *s;
+ if (!s) {
+ s = getenv("LC_ALL");
+ if (s == NULL)
+ s = getenv("LC_CTYPE");
+ if (s == NULL)
+ s = getenv("LANG");
+ }
+ return s;
+}
+
+int main(int ac, char** av)
+{
+ register int n;
+ char *ap;
+ char *av0;
+ char socknamebuf[2 * MAXSTR];
+ int mflag = 0;
+ char *myname = (ac == 0) ? "screen" : av[0];
+ char *SockDir;
+ struct stat st;
+#ifdef _MODE_T /* (jw) */
+ mode_t oumask;
+#else
+ int oumask;
+#endif
+#if defined(SYSV) && !defined(ISC)
+ struct utsname utsnam;
+#endif
+ struct NewWindow nwin;
+ int detached = 0; /* start up detached */
+#ifdef MULTIUSER
+ char *sockp;
+#endif
+ char *sty = 0;
+
+#if (defined(AUX) || defined(_AUX_SOURCE)) && defined(POSIX)
+ setcompat(COMPAT_POSIX|COMPAT_BSDPROT); /* turn on seteuid support */
+#endif
+#if defined(sun) && defined(SVR4)
+ {
+ /* Solaris' login blocks SIGHUP! This is _very bad_ */
+ sigset_t sset;
+ sigemptyset(&sset);
+ sigprocmask(SIG_SETMASK, &sset, 0);
+ }
+#endif
+
+ /*
+ * First, close all unused descriptors
+ * (otherwise, we might have problems with the select() call)
+ */
+ closeallfiles(0);
+#ifdef DEBUG
+ opendebug(1, 0);
+#endif
+ snprintf(version, 59, "%d.%.2d.%.2d%s (%s%s) %s", REV, VERS,
+ PATCHLEVEL, STATE, ORIGIN, GIT_REV, DATE);
+ nversion = REV * 10000 + VERS * 100 + PATCHLEVEL;
+ debug2("-- screen debug started %s (%s)\n", *av, version);
+#ifdef POSIX
+ debug("POSIX\n");
+#endif
+#ifdef TERMIO
+ debug("TERMIO\n");
+#endif
+#ifdef SYSV
+ debug("SYSV\n");
+#endif
+#ifdef SYSVSIGS
+ debug("SYSVSIGS\n");
+#endif
+#if defined(SIGWINCH) && defined(TIOCGWINSZ)
+ debug("Window size changing enabled\n");
+#endif
+#ifdef HAVE_SETREUID
+ debug("SETREUID\n");
+#endif
+#ifdef HAVE_SETEUID
+ debug("SETEUID\n");
+#endif
+#ifdef hpux
+ debug("hpux\n");
+#endif
+#ifdef USEBCOPY
+ debug("USEBCOPY\n");
+#endif
+#ifdef UTMPOK
+ debug("UTMPOK\n");
+#endif
+#ifdef LOADAV
+ debug("LOADAV\n");
+#endif
+#ifdef NETHACK
+ debug("NETHACK\n");
+#endif
+#ifdef TERMINFO
+ debug("TERMINFO\n");
+#endif
+#ifdef SHADOWPW
+ debug("SHADOWPW\n");
+#endif
+#ifdef NAME_MAX
+ debug1("NAME_MAX = %d\n", NAME_MAX);
+#endif
+
+ BellString = SaveStr("Bell in window %n");
+ VisualBellString = SaveStr(" Wuff, Wuff!! ");
+ ActivityString = SaveStr("Activity in window %n");
+ screenlogfile = SaveStr("screenlog.%n");
+ logtstamp_string = SaveStr("-- %n:%t -- time-stamp -- %M/%d/%y %c:%s --\n");
+ hstatusstring = SaveStr("%h");
+ captionstring = SaveStr("%4n %t");
+ timestring = SaveStr("%c:%s %M %d %H%? %l%?");
+ wlisttit = SaveStr(" Num Name%=Flags");
+ wliststr = SaveStr("%4n %t%=%f");
+#ifdef COPY_PASTE
+ BufferFile = SaveStr(DEFAULT_BUFFERFILE);
+#endif
+ ShellProg = NULL;
+#ifdef POW_DETACH
+ PowDetachString = 0;
+#endif
+ default_startup = (ac > 1) ? 0 : 1;
+ adaptflag = 0;
+ VBellWait = VBELLWAIT * 1000;
+ MsgWait = MSGWAIT * 1000;
+ MsgMinWait = MSGMINWAIT * 1000;
+ SilenceWait = SILENCEWAIT;
+#ifdef HAVE_BRAILLE
+ InitBraille();
+#endif
+#ifdef ZMODEM
+ zmodem_sendcmd = SaveStr("!!! sz -vv -b ");
+ zmodem_recvcmd = SaveStr("!!! rz -vv -b -E");
+#endif
+
+#ifdef COPY_PASTE
+ CompileKeys((char *)0, 0, mark_key_tab);
+#endif
+#ifdef UTF8
+ InitBuiltinTabs();
+ screenencodings = SaveStr(SCREENENCODINGS);
+#endif
+#ifdef DW_CHARS
+ cjkwidth = 0;
+#endif
+ nwin = nwin_undef;
+ nwin_options = nwin_undef;
+ strncpy(screenterm, "screen", MAXTERMLEN);
+ screenterm[MAXTERMLEN] = '\0';
+#ifdef BUILTIN_TELNET
+ af = AF_UNSPEC;
+#endif
+
+ real_uid = getuid();
+ real_gid = getgid();
+ eff_uid = geteuid();
+ eff_gid = getegid();
+
+ logreopen_register(lf_secreopen);
+
+ av0 = *av; /* if this is a login screen, assume -RR */
+ if (*av0 == '-') {
+ rflag = 4;
+#ifdef MULTI
+ xflag = 1;
+#else
+ dflag = 1;
+#endif
+ ShellProg = SaveStr(DefaultShell); /* to prevent nasty circles */
+ }
+
+ while (ac > 0){
+ ap = *++av;
+ if (--ac > 0 && *ap == '-') {
+ if (ap[1] == '-' && ap[2] == 0) {
+ av++;
+ ac--;
+ break;
+ }
+
+ if (ap[1] == '-' && !strcmp(ap, "--version"))
+ Panic(0, "Screen version %s", version);
+ if (ap[1] == '-' && !strcmp(ap, "--help"))
+ exit_with_usage(myname, NULL, NULL);
+
+ while (ap && *ap && *++ap) {
+ switch (*ap) {
+
+#ifdef BUILTIN_TELNET
+ case '4':
+ af = AF_INET;
+ break;
+
+ case '6':
+ af = AF_INET6;
+ break;
+#endif
+
+ case 'a':
+ nwin_options.aflag = 1;
+ break;
+
+ case 'A':
+ adaptflag = 1;
+ break;
+
+ case 'p': /* preselect */
+ if (*++ap)
+ preselect = ap;
+ else {
+ if (!--ac)
+ exit_with_usage(myname, "Specify a window to preselect with -p", NULL);
+ preselect = *++av;
+ }
+ ap = NULL;
+ break;
+
+#ifdef HAVE_BRAILLE
+ case 'B':
+ bd.bd_start_braille = 1;
+ break;
+#endif
+
+ case 'c':
+ if (*++ap)
+ RcFileName = ap;
+ else {
+ if (--ac == 0)
+ exit_with_usage(myname, "Specify an alternate rc-filename with -c", NULL);
+ RcFileName = *++av;
+ }
+ ap = NULL;
+ break;
+
+ case 'e':
+ if (!*++ap) {
+ if (--ac == 0)
+ exit_with_usage(myname, "Specify command characters with -e", NULL);
+ ap = *++av;
+ }
+ if (ParseEscape(ap))
+ Panic(0, "Two characters are required with -e option, not '%s'.", ap);
+ ap = NULL;
+ break;
+
+ case 'f':
+ ap++;
+ switch (*ap++) {
+ case 'n':
+ case '0':
+ nwin_options.flowflag = FLOW_NOW * 0;
+ break;
+ case '\0':
+ ap--;
+ /* FALLTHROUGH */
+ case 'y':
+ case '1':
+ nwin_options.flowflag = FLOW_NOW * 1;
+ break;
+ case 'a':
+ nwin_options.flowflag = FLOW_AUTOFLAG;
+ break;
+ default:
+ exit_with_usage(myname, "Unknown flow option -%s", --ap);
+ }
+ break;
+
+ case 'h':
+ if (--ac == 0)
+ exit_with_usage(myname, NULL, NULL);
+ nwin_options.histheight = atoi(*++av);
+ if (nwin_options.histheight < 0)
+ exit_with_usage(myname, "-h: %s: negative scrollback size?", *av);
+ break;
+
+ case 'i':
+ iflag = 1;
+ break;
+
+ case 't': /* title, the former AkA == -k */
+ if (--ac == 0)
+ exit_with_usage(myname, "Specify a new window-name with -t", NULL);
+ nwin_options.aka = *++av;
+ break;
+
+ case 'l':
+ ap++;
+ switch (*ap++) {
+ case 'n':
+ case '0':
+ nwin_options.lflag = 0;
+ break;
+ case '\0':
+ ap--;
+ /* FALLTHROUGH */
+ case 'y':
+ case '1':
+ nwin_options.lflag = 1;
+ break;
+ case 'a':
+ nwin_options.lflag = 3;
+ break;
+ case 's': /* -ls */
+ case 'i': /* -list */
+ lsflag = 1;
+ if (ac > 1 && !SockMatch) {
+ SockMatch = *++av;
+ ac--;
+ }
+ ap = NULL;
+ break;
+ default:
+ exit_with_usage(myname, "%s: Unknown suboption to -l", --ap);
+ }
+ break;
+
+ case 'w':
+ if (strcmp(ap+1, "ipe"))
+ exit_with_usage(myname, "Unknown option %s", --ap);
+ lsflag = 1;
+ wipeflag = 1;
+ if (ac > 1 && !SockMatch) {
+ SockMatch = *++av;
+ ac--;
+ }
+ break;
+
+ case 'L':
+ if (!strcmp(ap + 1, "ogfile")) {
+ if (--ac == 0)
+ exit_with_usage(myname, "Specify logfile path with -Logfile", NULL);
+
+ if (strlen(*++av) > PATH_MAX)
+ Panic(1, "-Logfile name too long. (max. %d char)", PATH_MAX);
+
+ free(screenlogfile); /* we already set it up while starting */
+ screenlogfile = SaveStr(*av);
+
+ ap = NULL;
+ } else if (!strcmp(ap, "L"))
+ nwin_options.Lflag = 1;
+
+ break;
+
+ case 'm':
+ mflag = 1;
+ break;
+
+ case 'O': /* to be (or not to be?) deleted. jw. */
+ force_vt = 0;
+ break;
+
+ case 'T':
+ if (--ac == 0)
+ exit_with_usage(myname, "Specify terminal-type with -T", NULL);
+ if (strlen(*++av) < MAXTERMLEN) {
+ strncpy(screenterm, *av, MAXTERMLEN);
+ screenterm[MAXTERMLEN] = '\0';
+ } else
+ Panic(0, "-T: terminal name too long. (max. %d char)", MAXTERMLEN);
+ nwin_options.term = screenterm;
+ break;
+
+ case 'q':
+ quietflag = 1;
+ break;
+
+ case 'Q':
+ queryflag = 1;
+ cmdflag = 1;
+ break;
+
+ case 'r':
+ case 'R':
+#ifdef MULTI
+ case 'x':
+#endif
+ if (ac > 1 && *av[1] != '-' && !SockMatch) {
+ SockMatch = *++av;
+ ac--;
+ debug2("rflag=%d, SockMatch=%s\n", dflag, SockMatch);
+ }
+#ifdef MULTI
+ if (*ap == 'x')
+ xflag = 1;
+#endif
+ if (rflag)
+ rflag = 2;
+ rflag += (*ap == 'R') ? 2 : 1;
+ break;
+
+#ifdef REMOTE_DETACH
+ case 'd':
+ dflag = 1;
+ /* FALLTHROUGH */
+
+ case 'D':
+ if (!dflag)
+ dflag = 2;
+ if (ac == 2) {
+ if (*av[1] != '-' && !SockMatch) {
+ SockMatch = *++av;
+ ac--;
+ debug2("dflag=%d, SockMatch=%s\n", dflag, SockMatch);
+ }
+ }
+ break;
+#endif
+
+ case 's':
+ if (--ac == 0)
+ exit_with_usage(myname, "Specify shell with -s", NULL);
+ if (ShellProg)
+ free(ShellProg);
+ ShellProg = SaveStr(*++av);
+ debug1("ShellProg: '%s'\n", ShellProg);
+ break;
+
+ case 'S':
+ if (!SockMatch) {
+ if (--ac == 0)
+ exit_with_usage(myname, "Specify session-name with -S", NULL);
+ SockMatch = *++av;
+ }
+ if (!*SockMatch)
+ exit_with_usage(myname, "Empty session-name?", NULL);
+ break;
+
+ case 'X':
+ cmdflag = 1;
+ break;
+
+ case 'v':
+ Panic(0, "Screen version %s", version);
+ /* NOTREACHED */
+
+#ifdef UTF8
+ case 'U':
+ nwin_options.encoding = nwin_options.encoding == -1 ? UTF8 : 0;
+ break;
+#endif
+
+ default:
+ exit_with_usage(myname, "Unknown option %s", --ap);
+ }
+ }
+ }
+ else
+ break;
+ }
+
+#ifdef SIGBUS /* OOPS, linux has no bus errors! */
+ signal(SIGBUS, CoreDump);
+#endif /* SIGBUS */
+ signal(SIGSEGV, CoreDump);
+
+
+#ifdef USE_LOCALE
+ setlocale(LC_ALL, "");
+#endif
+#ifdef ENCODINGS
+ if (nwin_options.encoding == -1) {
+ /* ask locale if we should start in UTF-8 mode */
+# ifdef HAVE_NL_LANGINFO
+# ifndef USE_LOCALE
+ setlocale(LC_CTYPE, "");
+# endif
+ nwin_options.encoding = FindEncoding(nl_langinfo(CODESET));
+ debug1("locale says encoding = %d\n", nwin_options.encoding);
+# else
+# ifdef UTF8
+ char *s;
+ if ((s = locale_name()) && InStr(s, "UTF-8"))
+ nwin_options.encoding = UTF8;
+# endif
+ debug1("environment says encoding=%d\n", nwin_options.encoding);
+#endif
+ }
+
+# ifdef DW_CHARS
+ {
+ char *s;
+ if ((s = locale_name())) {
+ if(!strncmp(s, "zh_", 3) || !strncmp(s, "ja_", 3) || !strncmp(s, "ko_", 3)) {
+ cjkwidth = 1;
+ }
+ }
+ }
+#endif
+#endif
+
+ if (nwin_options.aka) {
+#ifdef ENCODINGS
+ if (nwin_options.encoding > 0) {
+ size_t len = strlen(nwin_options.aka);
+ size_t newsz;
+ char *newbuf = malloc(3 * len);
+ if (!newbuf)
+ Panic(0, "%s", strnomem);
+ newsz = RecodeBuf((unsigned char *)nwin_options.aka, len,
+ nwin_options.encoding, 0, (unsigned char *)newbuf);
+ newbuf[newsz] = '\0';
+ nwin_options.aka = newbuf;
+ } else
+#endif
+ {
+ /* If we just use the original value from av,
+ subsequent shelltitle invocations will attempt to free
+ space we don't own... */
+ nwin_options.aka = SaveStr(nwin_options.aka);
+ }
+ }
+
+ if (SockMatch && strlen(SockMatch) >= MAXSTR)
+ Panic(0, "Ridiculously long socketname - try again.");
+ if (cmdflag && !rflag && !dflag && !xflag)
+ xflag = 1;
+ if (!cmdflag && dflag && mflag && !(rflag || xflag))
+ detached = 1;
+ nwin = nwin_options;
+
+#ifdef ENCODINGS
+ nwin.encoding = nwin_undef.encoding; /* let screenrc overwrite it */
+#endif
+ if (ac)
+ nwin.args = av;
+
+ /* make the write() calls return -1 on all errors */
+
+#ifdef SIGXFSZ
+ /*
+ * Ronald F. Guilmette, Oct 29 '94, bug-gnu-utils@prep.ai.mit.edu:
+ * It appears that in System V Release 4, UNIX, if you are writing
+ * an output file and you exceed the currently set file size limit,
+ * you _don't_ just get the call to `write' returning with a
+ * failure code. Rather, you get a signal called `SIGXFSZ' which,
+ * if neither handled nor ignored, will cause your program to crash
+ * with a core dump.
+ */
+ signal(SIGXFSZ, SIG_IGN);
+#endif /* SIGXFSZ */
+
+#ifdef SIGPIPE
+ signal(SIGPIPE, SIG_IGN);
+#endif
+
+ if (!ShellProg) {
+ register char *sh;
+ sh = getenv("SHELL");
+ ShellProg = SaveStr(sh ? sh : DefaultShell);
+ }
+ ShellArgs[0] = ShellProg;
+ home = getenv("HOME");
+ if (!mflag && !SockMatch) {
+ sty = getenv("STY");
+ if (sty && *sty == 0)
+ sty = 0;
+ }
+
+#ifdef NETHACK
+ if (!(nethackflag = (getenv("NETHACKOPTIONS") != NULL))) {
+ char nethackrc[MAXPATHLEN];
+
+ if (home && (strlen(home) < (MAXPATHLEN - 20))) {
+ sprintf(nethackrc,"%s/.nethackrc", home);
+ nethackflag = !access(nethackrc, F_OK);
+ }
+ }
+#endif
+
+#ifdef MULTIUSER
+ own_uid = multi_uid = real_uid;
+ if (SockMatch && (sockp = index(SockMatch, '/'))) {
+ *sockp = 0;
+ multi = SockMatch;
+ SockMatch = sockp + 1;
+ if (*multi) {
+ struct passwd *mppp;
+ if ((mppp = getpwnam(multi)) == (struct passwd *)0)
+ Panic(0, "Cannot identify account '%s'.", multi);
+ multi_uid = mppp->pw_uid;
+ multi_home = SaveStr(mppp->pw_dir);
+ if (strlen(multi_home) > MAXPATHLEN - 10)
+ Panic(0, "home directory path too long");
+
+# ifdef MULTI
+ /* always fake multi attach mode */
+ if (rflag || lsflag)
+ xflag = 1;
+# endif /* MULTI */
+ detached = 0;
+ multiattach = 1;
+ }
+ /* Special case: effective user is multiuser. */
+ if (eff_uid && (multi_uid != eff_uid))
+ Panic(0, "Must run suid root for multiuser support.");
+ }
+ if (SockMatch && *SockMatch == 0)
+ SockMatch = 0;
+#endif /* MULTIUSER */
+
+ if ((LoginName = getlogin()) && LoginName[0] != '\0') {
+ if ((ppp = getpwnam(LoginName)) != (struct passwd *) 0)
+ if ((int)ppp->pw_uid != real_uid)
+ ppp = (struct passwd *) 0;
+ }
+ if (ppp == 0) {
+ if ((ppp = getpwuid(real_uid)) == 0) {
+ Panic(0, "getpwuid() can't identify your account!");
+ exit(1);
+ }
+ LoginName = ppp->pw_name;
+ }
+ LoginName = SaveStr(LoginName);
+ ppp = getpwbyname(LoginName, ppp);
+
+#if !defined(SOCKDIR) && defined(MULTIUSER)
+ if (multi && !multiattach) {
+ if (home && strcmp(home, ppp->pw_dir))
+ Panic(0, "$HOME must match passwd entry for multiuser screens.");
+ }
+#endif
+
+#define SET_GUID() do \
+ { \
+ setgid(real_gid); \
+ setuid(real_uid); \
+ eff_uid = real_uid; \
+ eff_gid = real_gid; \
+ } while (0)
+
+ if (home == 0 || *home == '\0')
+ home = ppp->pw_dir;
+ if (strlen(LoginName) > MAXLOGINLEN)
+ Panic(0, "LoginName too long - sorry.");
+
+#ifdef MULTIUSER
+ if (multi && strlen(multi) > MAXLOGINLEN)
+ Panic(0, "Screen owner name too long - sorry.");
+#endif
+ if (strlen(home) > MAXPATHLEN - 25)
+ Panic(0, "$HOME too long - sorry.");
+
+ attach_tty = "";
+ if (!detached && !lsflag && !cmdflag && !(dflag && !mflag && !rflag && !xflag) &&
+ !(sty && !SockMatch && !mflag && !rflag && !xflag)) {
+ int fl;
+
+ /* ttyname implies isatty */
+ SetTtyname(true, &st);
+#ifdef MULTIUSER
+ tty_mode = (int)st.st_mode & 0777;
+#endif
+
+ fl = fcntl(0, F_GETFL, 0);
+ if (fl != -1 && (fl & (O_RDWR|O_RDONLY|O_WRONLY)) == O_RDWR)
+ attach_fd = 0;
+
+
+ if (attach_fd == -1) {
+ if ((n = secopen(attach_tty, O_RDWR | O_NONBLOCK, 0)) < 0)
+ Panic(0, "Cannot open your terminal '%s' - please check.", attach_tty);
+ /* If the server uses a socket we need an open fd. */
+ attach_fd = n;
+ }
+
+ debug2("attach_tty is %s, attach_fd is %d\n", attach_tty, attach_fd);
+
+ if ((attach_term = getenv("TERM")) == 0 || *attach_term == 0)
+ Panic(0, "Please set a terminal type.");
+ if (strlen(attach_term) > MAXTERMLEN)
+ Panic(0, "$TERM too long - sorry.");
+
+ GetTTY(0, &attach_Mode);
+#ifdef DEBUGGGGGGGGGGGGGGG
+ DebugTTY(&attach_Mode);
+#endif /* DEBUG */
+ }
+
+#ifdef _MODE_T
+ oumask = umask(0); /* well, unsigned never fails? jw. */
+#else
+ if ((oumask = (int)umask(0)) == -1)
+ Panic(errno, "Cannot change umask to zero");
+#endif
+
+ SockDir = getenv("SCREENDIR");
+ if (SockDir) {
+ if (strlen(SockDir) >= MAXPATHLEN - 1)
+ Panic(0, "Ridiculously long $SCREENDIR - try again.");
+
+#ifdef MULTIUSER
+ if (multi)
+ Panic(0, "No $SCREENDIR with multi screens, please.");
+#endif
+ }
+
+#ifdef MULTIUSER
+ if (multiattach) {
+# ifndef SOCKDIR
+ sprintf(SockPath, "%s/.screen", multi_home);
+ SockDir = SockPath;
+# else
+ SockDir = SOCKDIR;
+ sprintf(SockPath, "%s/S-%s", SockDir, multi);
+# endif
+ } else
+#endif
+
+ {
+#ifndef SOCKDIR
+ if (SockDir == 0) {
+ sprintf(SockPath, "%s/.screen", home);
+ SockDir = SockPath;
+ }
+#endif
+
+ if (SockDir) {
+ if (access(SockDir, F_OK)) {
+ debug1("SockDir '%s' missing ...\n", SockDir);
+ if (UserContext() > 0) {
+ if (mkdir(SockDir, 0700))
+ UserReturn(0);
+ UserReturn(1);
+ }
+
+ if (UserStatus() <= 0)
+ Panic(0, "Cannot make directory '%s'.", SockDir);
+ }
+ if (SockDir != SockPath)
+ strcpy(SockPath, SockDir);
+ }
+
+#ifdef SOCKDIR
+ else {
+ SockDir = SOCKDIR;
+ if (stat(SockDir, &st)) {
+ n = (eff_uid == 0 && (real_uid || eff_gid == real_gid)) ? 0755 :
+ (eff_gid != real_gid) ? 0775 :
+#ifdef S_ISVTX
+ 0777|S_ISVTX;
+#else
+ 0777;
+#endif
+
+ if (mkdir(SockDir, n) == -1)
+ Panic(errno, "Cannot make directory '%s'", SockDir);
+ }
+ else {
+ if (!S_ISDIR(st.st_mode))
+ Panic(0, "'%s' must be a directory.", SockDir);
+ if (eff_uid == 0 && real_uid && (int)st.st_uid != eff_uid)
+ Panic(0, "Directory '%s' must be owned by root.", SockDir);
+ n = (eff_uid == 0 && (real_uid || (st.st_mode & 0775) != 0775)) ? 0755 :
+ (eff_gid == (int)st.st_gid && eff_gid != real_gid) ? 0775 : 0777;
+ if (((int)st.st_mode & 0777) != n)
+ Panic(0, "Directory '%s' must have mode %03o.", SockDir, n);
+ }
+ sprintf(SockPath, "%s/S-%s", SockDir, LoginName);
+ if (access(SockPath, F_OK)) {
+ if (mkdir(SockPath, 0700) == -1 && errno != EEXIST)
+ Panic(errno, "Cannot make directory '%s'", SockPath);
+ (void) chown(SockPath, real_uid, real_gid);
+ }
+ }
+#endif
+ }
+
+ if (stat(SockPath, &st) == -1)
+ Panic(errno, "Cannot access %s", SockPath);
+ else
+ if (!S_ISDIR(st.st_mode))
+ Panic(0, "%s is not a directory.", SockPath);
+#ifdef MULTIUSER
+ if (multi) {
+ if ((int)st.st_uid != multi_uid)
+ Panic(0, "%s is not the owner of %s.", multi, SockPath);
+ }
+ else
+#endif
+
+ {
+#ifdef SOCKDIR
+/* if SOCKDIR is not defined, the socket is in $HOME.
+ in that case it does not make sense to compare uids. */
+
+ if ((int)st.st_uid != real_uid)
+ Panic(0, "You are not the owner of %s.", SockPath);
+#endif
+ }
+
+ if ((st.st_mode & 0777) != 0700)
+ Panic(0, "Directory %s must have mode 700.", SockPath);
+ if (SockMatch && index(SockMatch, '/'))
+ Panic(0, "Bad session name '%s'", SockMatch);
+ SockName = SockPath + strlen(SockPath) + 1;
+ *SockName = 0;
+ (void) umask(oumask);
+ debug2("SockPath: %s SockMatch: %s\n", SockPath, SockMatch ? SockMatch : "NULL");
+
+#if defined(SYSV) && !defined(ISC)
+ if (uname(&utsnam) == -1)
+ Panic(errno, "uname");
+ strncpy(HostName, utsnam.nodename, sizeof(utsnam.nodename) < MAXSTR ? sizeof(utsnam.nodename) : MAXSTR - 1);
+ HostName[sizeof(utsnam.nodename) < MAXSTR ? sizeof(utsnam.nodename) : MAXSTR - 1] = '\0';
+#else
+
+ (void) gethostname(HostName, MAXSTR);
+ HostName[MAXSTR - 1] = '\0';
+#endif
+ if ((ap = index(HostName, '.')) != NULL)
+ *ap = '\0';
+
+ if (lsflag) {
+ int i, fo, oth;
+ bool sock;
+
+#ifdef MULTIUSER
+ if (multi)
+ real_uid = multi_uid;
+#endif
+
+ SET_GUID();
+ i = FindSocket((int *)NULL, &fo, &oth, SockMatch, &sock);
+ if (quietflag) {
+ if (rflag)
+ exit(10 + i);
+ else
+ exit(9 + (fo || oth ? 1 : 0) + fo);
+ }
+ if (fo == 0)
+ Panic(0, "No Sockets found in %s.\n", SockPath);
+ Msg(0, "%d Socket%s in %s.", fo, fo > 1 ? "s" : "", SockPath);
+ eexit(0);
+ }
+ signal(SIG_BYE, AttacherFinit); /* prevent races */
+ if (cmdflag) {
+ /* attach_tty is not mandatory */
+ SetTtyname(false, &st);
+ if (!*av)
+ Panic(0, "Please specify a command.");
+ SET_GUID();
+ SendCmdMessage(sty, SockMatch, av, queryflag >= 0);
+ exit(0);
+ }
+ else if (rflag || xflag) {
+ debug("screen -r: - is there anybody out there?\n");
+ if (Attach(MSG_ATTACH)) {
+ Attacher();
+ /* NOTREACHED */
+ }
+#ifdef MULTIUSER
+ if (multiattach)
+ Panic(0, "Can't create sessions of other users.");
+#endif
+
+ debug("screen -r: backend not responding -- still crying\n");
+ }
+ else if (dflag && !mflag) {
+ SetTtyname(false, &st);
+ Attach(MSG_DETACH);
+ Msg(0, "[%s %sdetached.]\n", SockName, (dflag > 1 ? "power " : ""));
+ eexit(0);
+ /* NOTREACHED */
+ }
+ if (!SockMatch && !mflag && sty) {
+ /* attach_tty is not mandatory */
+ SetTtyname(false, &st);
+ SET_GUID();
+ nwin_options.args = av;
+ SendCreateMsg(sty, &nwin);
+ exit(0);
+ /* NOTREACHED */
+ }
+ nwin_compose(&nwin_default, &nwin_options, &nwin_default);
+
+ if (!detached || dflag != 2)
+ MasterPid = fork();
+ else
+ MasterPid = 0;
+
+ switch (MasterPid) {
+ case -1:
+ Panic(errno, "fork");
+ /* NOTREACHED */
+ case 0:
+ break;
+ default:
+ if (detached)
+ exit(0);
+ if (SockMatch)
+ sprintf(socknamebuf, "%d.%s", MasterPid, SockMatch);
+ else
+ sprintf(socknamebuf, "%d.%s.%s", MasterPid, stripdev(attach_tty), HostName);
+ for (ap = socknamebuf; *ap; ap++)
+ if (*ap == '/')
+ *ap = '-';
+#ifdef NAME_MAX
+ if (strlen(socknamebuf) > NAME_MAX)
+ socknamebuf[NAME_MAX] = 0;
+#endif
+ sprintf(SockPath + strlen(SockPath), "/%s", socknamebuf);
+ SET_GUID();
+ Attacher();
+ /* NOTREACHED */
+ }
+
+ if (!detached)
+ PanicPid = getppid();
+
+ if (DefaultEsc == -1)
+ DefaultEsc = Ctrl('a');
+ if (DefaultMetaEsc == -1)
+ DefaultMetaEsc = 'a';
+
+ ap = av0 + strlen(av0) - 1;
+ while (ap >= av0) {
+ if (!strncmp("screen", ap, 6)) {
+ strncpy(ap, "SCREEN", 6); /* name this process "SCREEN-BACKEND" */
+ break;
+ }
+ ap--;
+ }
+ if (ap < av0)
+ *av0 = 'S';
+
+#ifdef DEBUG
+ {
+ char buf[256];
+
+ if (dfp && dfp != stderr)
+ fclose(dfp);
+ sprintf(buf, "%s/SCREEN.%d", DEBUGDIR, (int)getpid());
+ if ((dfp = fopen(buf, "w")) == NULL)
+ dfp = stderr;
+ else
+ (void) chmod(buf, 0666);
+ }
+#endif
+
+ if (!detached) {
+ if (attach_fd == -1) {
+ if ((n = secopen(attach_tty, O_RDWR | O_NONBLOCK, 0)) < 0)
+ Panic(0, "Cannot reopen '%s' - please check.", attach_tty);
+ }
+ else
+ n = dup(attach_fd);
+ }
+ else
+ n = -1;
+ freopen("/dev/null", "r", stdin);
+ freopen("/dev/null", "w", stdout);
+
+#ifdef DEBUG
+ if (dfp != stderr)
+#endif
+ freopen("/dev/null", "w", stderr);
+ debug("-- screen.back debug started\n");
+
+ /* This guarantees that the session owner is listed, even when we
+ * start detached. From now on we should not refer to 'LoginName'
+ * any more, use users->u_name instead.
+ */
+ if (UserAdd(LoginName, (char *)0, (struct acluser **)0) < 0)
+ Panic(0, "Could not create user info");
+ if (!detached) {
+ if (MakeDisplay(LoginName, attach_tty, attach_term, n, getppid(), &attach_Mode) == 0)
+ Panic(0, "Could not alloc display");
+ PanicPid = 0;
+#ifdef ENCODINGS
+ D_encoding = nwin_options.encoding > 0 ? nwin_options.encoding : 0;
+ debug1("D_encoding = %d\n", D_encoding);
+#endif
+ }
+
+ if (SockMatch) {
+ /* user started us with -S option */
+ sprintf(socknamebuf, "%d.%s", (int)getpid(), SockMatch);
+ }
+ else {
+ sprintf(socknamebuf, "%d.%s.%s", (int)getpid(), stripdev(attach_tty), HostName);
+ }
+ for (ap = socknamebuf; *ap; ap++)
+ if (*ap == '/')
+ *ap = '-';
+
+#ifdef NAME_MAX
+ if (strlen(socknamebuf) > NAME_MAX) {
+ debug2("Socketname %s truncated to %d chars\n", socknamebuf, NAME_MAX);
+ socknamebuf[NAME_MAX] = 0;
+ }
+#endif
+
+ sprintf(SockPath + strlen(SockPath), "/%s", socknamebuf);
+ /* Always create sockets. We only allow attaching to fifos not creating
+ * new ones.
+ */
+ ServerSocket = MakeServerSocket(true);
+ InitKeytab();
+
+#ifdef ETCSCREENRC
+# ifdef ALLOW_SYSSCREENRC
+ if ((ap = getenv("SYSSCREENRC")))
+ (void)StartRc(ap, 0);
+ else
+# endif
+ (void)StartRc(ETCSCREENRC, 0);
+#endif
+ (void)StartRc(RcFileName, 0);
+# ifdef UTMPOK
+# ifndef UTNOKEEP
+ InitUtmp();
+# endif /* UTNOKEEP */
+# endif /* UTMPOK */
+ if (display) {
+ if (InitTermcap(0, 0)) {
+ debug("Could not init termcap - exiting\n");
+ fcntl(D_userfd, F_SETFL, 0); /* Flush sets FNBLOCK */
+ freetty();
+ if (D_userpid)
+ Kill(D_userpid, SIG_BYE);
+ eexit(1);
+ }
+ MakeDefaultCanvas();
+ InitTerm(0);
+#ifdef UTMPOK
+ RemoveLoginSlot();
+#endif
+ }
+ else
+ MakeTermcap(1);
+
+#ifdef LOADAV
+ InitLoadav();
+#endif /* LOADAV */
+
+ MakeNewEnv();
+ signal(SIGHUP, SigHup);
+ signal(SIGINT, FinitHandler);
+ signal(SIGQUIT, FinitHandler);
+ signal(SIGTERM, FinitHandler);
+#ifdef BSDJOBS
+ signal(SIGTTIN, SIG_IGN);
+ signal(SIGTTOU, SIG_IGN);
+#endif
+
+ if (display) {
+ brktty(D_userfd);
+ SetMode(&D_OldMode, &D_NewMode, D_flow, iflag);
+ /* Note: SetMode must be called _before_ FinishRc. */
+ SetTTY(D_userfd, &D_NewMode);
+ if (fcntl(D_userfd, F_SETFL, FNBLOCK))
+ Msg(errno, "Warning: NBLOCK fcntl failed");
+ }
+ else
+ brktty(-1); /* just try */
+ signal(SIGCHLD, SigChld);
+#ifdef ETCSCREENRC
+# ifdef ALLOW_SYSSCREENRC
+ if ((ap = getenv("SYSSCREENRC")))
+ FinishRc(ap);
+ else
+# endif
+ FinishRc(ETCSCREENRC);
+#endif
+ FinishRc(RcFileName);
+
+ debug2("UID %d EUID %d\n", (int)getuid(), (int)geteuid());
+ if (windows == NULL) {
+ debug("We open one default window, as screenrc did not specify one.\n");
+ if (MakeWindow(&nwin) == -1) {
+ fd_set rfd;
+ struct timeval tv = { MsgWait/1000, 1000*(MsgWait%1000) };
+ FD_SET(0, &rfd);
+
+ Msg(0, "Sorry, could not find a PTY or TTY.");
+ // allow user to exit early by pressing any key.
+ select(1, &rfd, NULL, NULL, &tv);
+ Finit(0);
+ /* NOTREACHED */
+ }
+ }
+ else if (ac) /* Screen was invoked with a command */
+ MakeWindow(&nwin);
+
+#ifdef HAVE_BRAILLE
+ StartBraille();
+#endif
+
+ if (display && default_startup)
+ display_copyright();
+ signal(SIGINT, SigInt);
+ if (rflag && (rflag & 1) == 0 && !quietflag) {
+ Msg(0, "New screen...");
+ rflag = 0;
+ }
+
+ serv_read.type = EV_READ;
+ serv_read.fd = ServerSocket;
+ serv_read.handler = serv_read_fn;
+ evenq(&serv_read);
+
+ serv_select.pri = -10;
+ serv_select.type = EV_ALWAYS;
+ serv_select.handler = serv_select_fn;
+ evenq(&serv_select);
+
+ logflushev.type = EV_TIMEOUT;
+ logflushev.handler = logflush_fn;
+
+ sched();
+ /* NOTREACHED */
+ return 0;
+}
+
+void
+WindowDied(p, wstat, wstat_valid)
+struct win *p;
+#ifdef BSDWAIT
+ union wait wstat;
+#else
+ int wstat;
+#endif
+
+
+int wstat_valid;
+{
+ int killit = 0;
+ if (p->w_destroyev.data == (char *)p) {
+ wstat = p->w_exitstatus;
+ wstat_valid = 1;
+ evdeq(&p->w_destroyev);
+ p->w_destroyev.data = 0;
+ }
+
+#if defined(BSDJOBS) && !defined(BSDWAIT)
+ if (!wstat_valid && p->w_pid > 0) {
+ /* EOF on file descriptor. The process is probably also dead.
+ * try a waitpid */
+ if (waitpid(p->w_pid, &wstat, WNOHANG | WUNTRACED) == p->w_pid) {
+ p->w_pid = 0;
+ wstat_valid = 1;
+ }
+ }
+#endif
+
+ if (ZombieKey_destroy && ZombieKey_onerror && wstat_valid &&
+ WIFEXITED(wstat) && WEXITSTATUS(wstat) == 0)
+ killit = 1;
+
+ if (ZombieKey_destroy && !killit) {
+ char buf[100], *s, reason[100];
+ time_t now;
+
+ if (wstat_valid) {
+ if (WIFEXITED(wstat))
+ if (WEXITSTATUS(wstat))
+ sprintf(reason, "terminated with exit status %d", WEXITSTATUS(wstat));
+ else
+ sprintf(reason, "terminated normally");
+ else if (WIFSIGNALED(wstat))
+ sprintf(reason, "terminated with signal %d%s", WTERMSIG(wstat),
+
+#ifdef WCOREDUMP
+ WCOREDUMP(wstat) ? " (core file generated)" : "");
+#else
+ "");
+#endif
+ } else
+ sprintf(reason, "detached from window");
+
+ (void) time(&now);
+ s = ctime(&now);
+ if (s && *s)
+ s[strlen(s) - 1] = '\0';
+ debug3("window %d (%s) going into zombie state fd %d", p->w_number, p->w_title, p->w_ptyfd);
+
+#ifdef UTMPOK
+ if (p->w_slot != (slot_t)0 && p->w_slot != (slot_t)-1) {
+ RemoveUtmp(p);
+ p->w_slot = 0; /* "detached" */
+ }
+#endif
+
+ CloseDevice(p);
+ p->w_deadpid = p->w_pid;
+ p->w_pid = 0;
+ ResetWindow(p);
+ /* p->w_y = p->w_bot; */
+ p->w_y = MFindUsedLine(p, p->w_bot, 1);
+ sprintf(buf, "\n\r=== Command %s (%s) ===", reason, s ? s : "?");
+ WriteString(p, buf, strlen(buf));
+ if (p->w_poll_zombie_timeout) {
+ debug2("Set zombie poll timeout for window %s to %d\n", p->w_title,
+ p->w_poll_zombie_timeout);
+ SetTimeout(&p->w_zombieev, p->w_poll_zombie_timeout * 1000);
+ evenq(&p->w_zombieev);
+ }
+ WindowChanged(p, 'f');
+ }
+ else
+ KillWindow(p);
+
+#ifdef UTMPOK
+ CarefulUtmp();
+#endif
+}
+
+static void SigChldHandler()
+{
+ struct stat st;
+#ifdef DEBUG
+ fds();
+#endif
+ while (GotSigChld) {
+ GotSigChld = 0;
+ DoWait();
+#ifdef SYSVSIGS
+ signal(SIGCHLD, SigChld);
+#endif
+ }
+ if (stat(SockPath, &st) == -1) {
+ debug1("SigChldHandler: Yuck! cannot stat '%s'\n", SockPath);
+ if (!RecoverSocket()) {
+ debug("SCREEN cannot recover from corrupt Socket, bye\n");
+ Finit(1);
+ }
+ else
+ debug1("'%s' reconstructed\n", SockPath);
+ }
+ else
+ debug2("SigChldHandler: stat '%s' o.k. (%03o)\n", SockPath, (int)st.st_mode);
+}
+
+static sigret_t SigChld SIGDEFARG
+{
+ debug("SigChld()\n");
+ GotSigChld = 1;
+ SIGRETURN;
+}
+
+sigret_t SigHup SIGDEFARG
+{
+ /* Hangup all displays */
+ while ((display = displays) != 0)
+ Hangup();
+ SIGRETURN;
+}
+
+/*
+ * the backend's Interrupt handler
+ * we cannot insert the intrc directly, as we never know
+ * if fore is valid.
+ */
+static sigret_t SigInt SIGDEFARG
+{
+#if HAZARDOUS
+ char ibuf;
+ debug("SigInt()\n");
+ if (fore && displays) {
+# if defined(TERMIO) || defined(POSIX)
+ ibuf = displays->d_OldMode.tio.c_cc[VINTR];
+# else
+ ibuf = displays->d_OldMode.m_tchars.t_intrc;
+# endif
+ fore->w_inlen = 0;
+ write(fore->w_ptyfd, &ibuf, 1);
+ }
+#else
+ signal(SIGINT, SigInt);
+ debug("SigInt() careful\n");
+ InterruptPlease = 1;
+#endif
+ SIGRETURN;
+}
+
+static sigret_t CoreDump SIGDEFARG
+{
+ /* if running with s-bit, we must reset the s-bit, so that we get a
+ * core file anyway.
+ */
+ struct display *disp;
+ char buf[80];
+ char *dump_msg = " (core dumped)";
+ int running_w_s_bit = getuid() != geteuid();
+
+#if defined(SHADOWPW) && !defined(DEBUG) && !defined(DUMPSHADOW)
+ if (running_w_s_bit)
+ dump_msg = "";
+#endif
+
+#if defined(SYSVSIGS) && defined(SIGHASARG)
+ signal(sigsig, SIG_IGN);
+#endif
+ setgid(getgid());
+ setuid(getuid());
+ unlink("core");
+
+#ifdef SIGHASARG
+ sprintf(buf, "\r\n[screen caught signal %d.%s]\r\n", sigsig, dump_msg);
+#else
+ sprintf(buf, "\r\n[screen caught a fatal signal.%s]\r\n", dump_msg);
+#endif
+
+ for (disp = displays; disp; disp = disp->d_next) {
+ if (disp->d_nonblock < -1 || disp->d_nonblock > 1000000)
+ continue;
+ fcntl(disp->d_userfd, F_SETFL, 0);
+ SetTTY(disp->d_userfd, &D_OldMode);
+ write(disp->d_userfd, buf, strlen(buf));
+ Kill(disp->d_userpid, SIG_BYE);
+ }
+
+ if (running_w_s_bit) {
+#if defined(SHADOWPW) && !defined(DEBUG) && !defined(DUMPSHADOW)
+ Kill(getpid(), SIGKILL);
+ eexit(11);
+#else /* SHADOWPW && !DEBUG */
+ abort();
+#endif /* SHADOWPW && !DEBUG */
+ }
+ else
+ abort();
+
+ SIGRETURN;
+}
+
+static void DoWait()
+{
+ register int pid;
+ struct win *p, *next;
+#ifdef BSDWAIT
+ union wait wstat;
+#else
+ int wstat;
+#endif
+
+#ifdef BSDJOBS
+
+# ifndef BSDWAIT
+ while ((pid = waitpid(-1, &wstat, WNOHANG | WUNTRACED)) > 0)
+# else
+
+# ifdef USE_WAIT2
+ /*
+ * From: rouilj@sni-usa.com (John Rouillard)
+ * note that WUNTRACED is not documented to work, but it is defined in
+ * /usr/include/sys/wait.h, so it may work
+ */
+ while ((pid = wait2(&wstat, WNOHANG | WUNTRACED )) > 0)
+# else /* USE_WAIT2 */
+ while ((pid = wait3(&wstat, WNOHANG | WUNTRACED, (struct rusage *) 0)) > 0)
+# endif /* USE_WAIT2 */
+# endif
+
+#else /* BSDJOBS */
+ while ((pid = wait(&wstat)) < 0)
+ if (errno != EINTR)
+ break;
+ if (pid > 0)
+
+#endif /* BSDJOBS */
+ {
+ for (p = windows; p; p = next) {
+ next = p->w_next;
+ if ((p->w_pid && pid == p->w_pid) || (p->w_deadpid && pid == p->w_deadpid)) {
+ /* child has ceased to exist */
+ p->w_pid = 0;
+
+#ifdef BSDJOBS
+ if (WIFSTOPPED(wstat)) {
+ debug3("Window %d pid %d: WIFSTOPPED (sig %d)\n", p->w_number, pid, WSTOPSIG(wstat));
+
+#ifdef SIGTTIN
+ if (WSTOPSIG(wstat) == SIGTTIN) {
+ Msg(0, "Suspended (tty input)");
+ continue;
+ }
+#endif
+
+
+#ifdef SIGTTOU
+ if (WSTOPSIG(wstat) == SIGTTOU) {
+ Msg(0, "Suspended (tty output)");
+ continue;
+ }
+#endif
+
+ /* Try to restart process */
+ Msg(0, "Child has been stopped, restarting.");
+ if (killpg(pid, SIGCONT))
+ kill(pid, SIGCONT);
+ }
+ else
+#endif
+ {
+ /* Screen will detect the window has died when the window's
+ * file descriptor signals EOF (which it will do when the process in
+ * the window terminates). So do this in a timeout of 10 seconds.
+ * (not doing this at all might also work)
+ * See #27061 for more details.
+ */
+ p->w_destroyev.data = (char *)p;
+ p->w_exitstatus = wstat;
+ SetTimeout(&p->w_destroyev, 10 * 1000);
+ evenq(&p->w_destroyev);
+ }
+ break;
+ }
+
+#ifdef PSEUDOS
+ if (p->w_pwin && pid == p->w_pwin->p_pid) {
+ debug2("pseudo of win Nr %d died. pid == %d\n", p->w_number, p->w_pwin->p_pid);
+ FreePseudowin(p);
+ break;
+ }
+
+#endif
+ }
+
+ if (p == 0) {
+ debug1("pid %d not found - hope that's ok\n", pid);
+ }
+ }
+}
+
+static sigret_t FinitHandler SIGDEFARG
+{
+#ifdef SIGHASARG
+ debug1("FinitHandler called, sig %d.\n", sigsig);
+#else
+ debug("FinitHandler called.\n");
+#endif
+ Finit(1);
+ SIGRETURN;
+}
+
+void Finit(int i)
+{
+ signal(SIGCHLD, SIG_DFL);
+ signal(SIGHUP, SIG_IGN);
+ debug1("Finit(%d);\n", i);
+ while (windows) {
+ struct win *p = windows;
+ windows = windows->w_next;
+ FreeWindow(p);
+ }
+
+ if (ServerSocket != -1) {
+ debug1("we unlink(%s)\n", SockPath);
+#ifdef USE_SETEUID
+ xseteuid(real_uid);
+ xsetegid(real_gid);
+#endif
+ (void) unlink(SockPath);
+#ifdef USE_SETEUID
+ xseteuid(eff_uid);
+ xsetegid(eff_gid);
+#endif
+ }
+
+ for (display = displays; display; display = display->d_next) {
+ if (D_status)
+ RemoveStatus();
+ FinitTerm();
+#ifdef UTMPOK
+ RestoreLoginSlot();
+#endif
+ AddStr("[screen is terminating]\r\n");
+ Flush(3);
+ SetTTY(D_userfd, &D_OldMode);
+ fcntl(D_userfd, F_SETFL, 0);
+ freetty();
+ Kill(D_userpid, SIG_BYE);
+ }
+ /*
+ * we _cannot_ call eexit(i) here,
+ * instead of playing with the Socket above. Sigh.
+ */
+ exit(i);
+}
+
+void eexit(int e)
+{
+ debug("eexit\n");
+ if (ServerSocket != -1) {
+ debug1("we unlink(%s)\n", SockPath);
+ setgid(real_gid);
+ setuid(real_uid);
+ (void) unlink(SockPath);
+ }
+ exit(e);
+}
+
+void Hangup()
+{
+ if (display == 0)
+ return;
+ debug1("Hangup %x\n", display);
+ if (D_userfd >= 0) {
+ close(D_userfd);
+ D_userfd = -1;
+ }
+ if (auto_detach || displays->d_next)
+ Detach(D_HANGUP);
+ else
+ Finit(0);
+}
+
+/*
+ * Detach now has the following modes:
+ *D_DETACH SIG_BYE detach backend and exit attacher
+ *D_HANGUP SIG_BYE detach backend and exit attacher
+ *D_STOP SIG_STOP stop attacher (and detach backend)
+ *D_REMOTE SIG_BYE remote detach -- reattach to new attacher
+ *D_POWER SIG_POWER_BYE power detach -- attacher kills his parent
+ *D_REMOTE_POWER SIG_POWER_BYE remote power detach -- both
+ *D_LOCK SIG_LOCK lock the attacher
+ * (jw)
+ * we always remove our utmp slots. (even when "lock" or "stop")
+ * Note: Take extra care here, we may be called by interrupt!
+ */
+void Detach(int mode)
+{
+ int sign = 0, pid;
+ struct canvas *cv;
+ struct win *p;
+
+ if (display == 0)
+ return;
+
+#define AddStrSock(msg) do { \
+ if (SockName) \
+ { \
+ AddStr("[" msg " from "); \
+ AddStr(SockName); \
+ AddStr("]\r\n"); \
+ } \
+ else \
+ AddStr("[" msg "]\r\n"); \
+ } while (0)
+
+ signal(SIGHUP, SIG_IGN);
+ debug1("Detach(%d)\n", mode);
+ if (D_status)
+ RemoveStatus();
+ FinitTerm();
+ if (!display)
+ return;
+ switch (mode) {
+
+ case D_HANGUP:
+ sign = SIG_BYE;
+ break;
+
+ case D_DETACH:
+ AddStrSock("detached");
+ sign = SIG_BYE;
+ break;
+
+#ifdef BSDJOBS
+ case D_STOP:
+ sign = SIG_STOP;
+ break;
+#endif
+
+#ifdef REMOTE_DETACH
+ case D_REMOTE:
+ AddStrSock("remote detached");
+ sign = SIG_BYE;
+ break;
+#endif
+
+#ifdef POW_DETACH
+ case D_POWER:
+ AddStrSock("power detached");
+ if (PowDetachString) {
+ AddStr(PowDetachString);
+ AddStr("\r\n");
+ }
+ sign = SIG_POWER_BYE;
+ break;
+
+#ifdef REMOTE_DETACH
+ case D_REMOTE_POWER:
+ AddStrSock("remote power detached");
+ if (PowDetachString) {
+ AddStr(PowDetachString);
+ AddStr("\r\n");
+ }
+ sign = SIG_POWER_BYE;
+ break;
+#endif
+#endif
+
+ case D_LOCK:
+ ClearAll();
+ sign = SIG_LOCK;
+ /* tell attacher to lock terminal with a lockprg. */
+ break;
+ }
+
+#ifdef UTMPOK
+ if (displays->d_next == 0) {
+ for (p = windows; p; p = p->w_next) {
+ if (p->w_slot != (slot_t) -1 && !(p->w_lflag & 2)) {
+ RemoveUtmp(p);
+
+ /* Set the slot to 0 to get the window logged in again. */
+ p->w_slot = (slot_t) 0;
+ }
+ }
+ }
+ if (mode != D_HANGUP)
+ RestoreLoginSlot();
+#endif
+
+ if (displays->d_next == 0 && console_window) {
+ if (TtyGrabConsole(console_window->w_ptyfd, 0, "detach")) {
+ debug("could not release console - killing window\n");
+ KillWindow(console_window);
+ display = displays; /* restore display */
+ }
+ }
+ if (D_fore) {
+#ifdef MULTIUSER
+ ReleaseAutoWritelock(display, D_fore);
+#endif
+ D_user->u_detachwin = D_fore->w_number;
+ D_user->u_detachotherwin = D_other ? D_other->w_number : -1;
+ }
+
+ AutosaveLayout(D_layout);
+ layout_last = D_layout;
+ for (cv = D_cvlist; cv; cv = cv->c_next) {
+ p = Layer2Window(cv->c_layer);
+ SetCanvasWindow(cv, 0);
+ if (p)
+ WindowChanged(p, 'u');
+ }
+
+ pid = D_userpid;
+ debug2("display: %#x displays: %#x\n", (unsigned int)display, (unsigned int)displays);
+ FreeDisplay();
+
+ if (displays == 0) /* Flag detached-ness */
+ (void) chsock();
+
+ /*
+ * tell father what to do. We do that after we
+ * freed the tty, thus getty feels more comfortable on hpux
+ * if it was a power detach.
+ */
+ Kill(pid, sign);
+ debug2("Detach: Signal %d to Attacher(%d)!\n", sign, pid);
+ debug("Detach returns, we are successfully detached.\n");
+ signal(SIGHUP, SigHup);
+#undef AddStrSock
+}
+
+static int IsSymbol(char *e, char *s)
+{
+ register int l;
+
+ l = strlen(s);
+ return strncmp(e, s, l) == 0 && e[l] == '=';
+}
+
+void MakeNewEnv()
+{
+ register char **op, **np;
+ static char stybuf[MAXSTR];
+
+ for (op = environ; *op; ++op)
+ ;
+ if (NewEnv)
+ free((char *)NewEnv);
+ NewEnv = np = (char **) malloc((unsigned) (op - environ + 7 + 1) * sizeof(char **));
+ if (!NewEnv)
+ Panic(0, "%s", strnomem);
+ sprintf(stybuf, "STY=%s", strlen(SockName) <= MAXSTR - 5 ? SockName : "?");
+ *np++ = stybuf; /* NewEnv[0] */
+ *np++ = Term; /* NewEnv[1] */
+ np++; /* room for SHELL */
+#ifdef TIOCSWINSZ
+ np += 2; /* room for TERMCAP and WINDOW */
+#else
+ np += 4; /* room for TERMCAP WINDOW LINES COLUMNS */
+#endif
+
+ for (op = environ; *op; ++op) {
+ if (!IsSymbol(*op, "TERM") && !IsSymbol(*op, "TERMCAP")
+ && !IsSymbol(*op, "STY") && !IsSymbol(*op, "WINDOW")
+ && !IsSymbol(*op, "SCREENCAP") && !IsSymbol(*op, "SHELL")
+ && !IsSymbol(*op, "LINES") && !IsSymbol(*op, "COLUMNS"))
+ *np++ = *op;
+ }
+ *np = 0;
+}
+
+#if defined(USEVARARGS) && defined(__STDC__)
+ #define DEFINE_VARARGS_FN(fnname) void fnname (int err, const char *fmt, VA_DOTS)
+#else
+ #define DEFINE_VARARGS_FN(fnname) void fnname(err, fmt, VA_DOTS) \
+ int err; \
+ const char *fmt; \
+ VA_DECL
+#endif
+
+#define PROCESS_MESSAGE(B) do { \
+ char *p = B; \
+ VA_LIST(ap) \
+ VA_START(ap, fmt); \
+ fmt = DoNLS(fmt); \
+ (void)vsnprintf(p, sizeof(B) - 100, fmt, VA_ARGS(ap)); \
+ VA_END(ap); \
+ if (err) \
+ { \
+ p += strlen(p); \
+ *p++ = ':'; \
+ *p++ = ' '; \
+ strncpy(p, strerror(err), B + sizeof(B) - p - 1); \
+ B[sizeof(B) - 1] = 0; \
+ } \
+ } while (0)
+
+DEFINE_VARARGS_FN(Msg)
+{
+ char buf[MAXPATHLEN*2];
+ PROCESS_MESSAGE(buf);
+
+ debug2("Msg('%s') (%#x);\n", buf, (unsigned int)display);
+
+ if (display && displays)
+ MakeStatus(buf);
+ else if (displays) {
+ for (display = displays; display; display = display->d_next)
+ MakeStatus(buf);
+ }
+ else if (display) {
+ /* no displays but a display - must have forked.
+ * send message to backend!
+ */
+ char *tty = D_usertty;
+ struct display *olddisplay = display;
+ display = 0; /* only send once */
+ SendErrorMsg(tty, buf);
+ display = olddisplay;
+ }
+ else
+ printf("%s\r\n", buf);
+
+ if (queryflag >= 0)
+ write(queryflag, buf, strlen(buf));
+}
+
+/*
+ * Call FinitTerm for all displays, write a message to each and call eexit();
+ */
+DEFINE_VARARGS_FN(Panic)
+{
+ char buf[MAXPATHLEN*2];
+ PROCESS_MESSAGE(buf);
+
+ debug3("Panic('%s'); display=%x displays=%x\n", buf, display, displays);
+ if (displays == 0 && display == 0) {
+ printf("%s\r\n", buf);
+ if (PanicPid)
+ Kill(PanicPid, SIG_BYE);
+ }
+ else if (displays == 0) {
+ /* no displays but a display - must have forked.
+ * send message to backend!
+ */
+ char *tty = D_usertty;
+ display = 0;
+ SendErrorMsg(tty, buf);
+ sleep(2);
+ _exit(1);
+ }
+ else
+ for (display = displays; display; display = display->d_next) {
+ if (D_status)
+ RemoveStatus();
+ FinitTerm();
+ Flush(3);
+#ifdef UTMPOK
+ RestoreLoginSlot();
+#endif
+ SetTTY(D_userfd, &D_OldMode);
+ fcntl(D_userfd, F_SETFL, 0);
+ write(D_userfd, buf, strlen(buf));
+ write(D_userfd, "\n", 1);
+ freetty();
+ if (D_userpid)
+ Kill(D_userpid, SIG_BYE);
+ }
+#ifdef MULTIUSER
+ if (tty_oldmode >= 0) {
+
+# ifdef USE_SETEUID
+ if (setuid(own_uid))
+ xseteuid(own_uid); /* may be a loop. sigh. */
+# else
+ setuid(own_uid);
+# endif
+
+ debug1("Panic: changing back modes from %s\n", attach_tty);
+ chmod(attach_tty, tty_oldmode);
+ }
+#endif
+ eexit(1);
+}
+
+DEFINE_VARARGS_FN(QueryMsg)
+{
+ char buf[MAXPATHLEN*2];
+
+ if (queryflag < 0)
+ return;
+
+ PROCESS_MESSAGE(buf);
+ write(queryflag, buf, strlen(buf));
+}
+
+DEFINE_VARARGS_FN(Dummy)
+{}
+
+#undef PROCESS_MESSAGE
+#undef DEFINE_VARARGS_FN
+
+/*
+ * '^' is allowed as an escape mechanism for control characters. jw.
+ *
+ * Added time insertion using ideas/code from /\ndy Jones
+ * (andy@lingua.cltr.uq.OZ.AU) - thanks a lot!
+ *
+ */
+
+#ifndef USE_LOCALE
+static const char days[] = "SunMonTueWedThuFriSat";
+static const char months[] = "JanFebMarAprMayJunJulAugSepOctNovDec";
+#endif
+
+static char winmsg_buf[MAXSTR];
+#define MAX_WINMSG_REND 256 /* rendition changes */
+static int winmsg_rend[MAX_WINMSG_REND];
+static int winmsg_rendpos[MAX_WINMSG_REND];
+static int winmsg_numrend;
+
+static char *pad_expand(char *buf, char *p, int numpad, int padlen)
+{
+ char *pn, *pn2;
+ int i, r;
+
+ padlen = padlen - (p - buf); /* space for rent */
+ if (padlen < 0)
+ padlen = 0;
+ pn2 = pn = p + padlen;
+ r = winmsg_numrend;
+ while (p >= buf) {
+ if (r && *p != 127 && p - buf == winmsg_rendpos[r - 1]) {
+ winmsg_rendpos[--r] = pn - buf;
+ continue;
+ }
+ *pn-- = *p;
+ if (*p-- == 127) {
+ pn[1] = ' ';
+ i = numpad > 0 ? (padlen + numpad - 1) / numpad : 0;
+ padlen -= i;
+
+ while (i-- > 0)
+ *pn-- = ' ';
+
+ numpad--;
+ if (r && p - buf + 1== winmsg_rendpos[r - 1])
+ winmsg_rendpos[--r] = pn - buf + 1;
+ }
+ }
+ return pn2;
+}
+
+struct backtick {
+ struct backtick *next;
+ int num;
+ int tick;
+ int lifespan;
+ time_t bestbefore;
+ char result[MAXSTR];
+ char **cmdv;
+ struct event ev;
+ char *buf;
+ int bufi;
+};
+
+struct backtick *backticks;
+
+static void backtick_filter(struct backtick *bt)
+{
+ char *p, *q;
+ int c;
+
+ for (p = q = bt->result; (c = (unsigned char)*p++) != 0;) {
+ if (c == '\t')
+ c = ' ';
+ if (c >= ' ' || c == '\005')
+ *q++ = c;
+ }
+ *q = 0;
+}
+
+static void backtick_fn(struct event *ev, char *data)
+{
+ struct backtick *bt;
+ int i, j, k, l;
+
+ bt = (struct backtick *)data;
+ debug1("backtick_fn for #%d\n", bt->num);
+ i = bt->bufi;
+ l = read(ev->fd, bt->buf + i, MAXSTR - i);
+
+ if (l <= 0) {
+ debug1("EOF on backtick #%d\n", bt->num);
+ evdeq(ev);
+ close(ev->fd);
+ ev->fd = -1;
+ return;
+ }
+
+ debug1("read %d bytes\n", l);
+ i += l;
+ for (j = 0; j < l; j++)
+ if (bt->buf[i - j - 1] == '\n')
+ break;
+
+ if (j < l) {
+ for (k = i - j - 2; k >= 0; k--)
+ if (bt->buf[k] == '\n')
+ break;
+ k++;
+ bcopy(bt->buf + k, bt->result, i - j - k);
+ bt->result[i - j - k - 1] = 0;
+ backtick_filter(bt);
+ WindowChanged(0, '`');
+ }
+
+ if (j == l && i == MAXSTR) {
+ j = MAXSTR/2;
+ l = j + 1;
+ }
+
+ if (j < l){
+ if (j)
+ bcopy(bt->buf + i - j, bt->buf, j);
+ i = j;
+ }
+ bt->bufi = i;
+}
+
+void setbacktick(int num, int lifespan, int tick, char **cmdv)
+{
+ struct backtick **btp, *bt;
+ char **v;
+
+ debug1("setbacktick called for backtick #%d\n", num);
+ for (btp = &backticks; (bt = *btp) != 0; btp = &bt->next)
+ if (bt->num == num)
+ break;
+
+ if (!bt && !cmdv)
+ return;
+
+ if (bt) {
+ for (v = bt->cmdv; *v; v++)
+ free(*v);
+ free(bt->cmdv);
+ if (bt->buf)
+ free(bt->buf);
+ if (bt->ev.fd >= 0)
+ close(bt->ev.fd);
+ evdeq(&bt->ev);
+ }
+
+ if (bt && !cmdv) {
+ *btp = bt->next;
+ free(bt);
+ return;
+ }
+
+ if (!bt){
+ bt = (struct backtick *)malloc(sizeof *bt);
+ if (!bt){
+ Msg(0, "%s", strnomem);
+ return;
+ }
+ bzero(bt, sizeof(*bt));
+ bt->next = 0;
+ *btp = bt;
+ }
+
+ bt->num = num;
+ bt->tick = tick;
+ bt->lifespan = lifespan;
+ bt->bestbefore = 0;
+ bt->result[0] = 0;
+ bt->buf = 0;
+ bt->bufi = 0;
+ bt->cmdv = cmdv;
+ bt->ev.fd = -1;
+
+ if (bt->tick == 0 && bt->lifespan == 0) {
+ debug("setbacktick: continuous mode\n");
+ bt->buf = (char *)malloc(MAXSTR);
+ if (bt->buf == 0) {
+ Msg(0, "%s", strnomem);
+ setbacktick(num, 0, 0, (char **)0);
+ return;
+ }
+
+ bt->ev.type = EV_READ;
+ bt->ev.fd = readpipe(bt->cmdv);
+ bt->ev.handler = backtick_fn;
+ bt->ev.data = (char *)bt;
+ if (bt->ev.fd >= 0)
+ evenq(&bt->ev);
+ }
+}
+
+static char * runbacktick(struct backtick *bt, int *tickp, time_t now)
+{
+ int f, i, l, j;
+ time_t now2;
+
+ debug1("runbacktick called for backtick #%d\n", bt->num);
+ if (bt->tick && (!*tickp || bt->tick < *tickp))
+ *tickp = bt->tick;
+ if ((bt->lifespan == 0 && bt->tick == 0) || now < bt->bestbefore) {
+ debug1("returning old result (%d)\n", bt->lifespan);
+ return bt->result;
+ }
+
+ f = readpipe(bt->cmdv);
+ if (f == -1)
+ return bt->result;
+ i = 0;
+ while ((l = read(f, bt->result + i, sizeof(bt->result) - i)) > 0) {
+ debug1("runbacktick: read %d bytes\n", l);
+ i += l;
+ for (j = 1; j < l; j++)
+ if (bt->result[i - j - 1] == '\n')
+ break;
+
+ if (j == l && i == sizeof(bt->result)) {
+ j = sizeof(bt->result) / 2;
+ l = j + 1;
+ }
+
+ if (j < l) {
+ bcopy(bt->result + i - j, bt->result, j);
+ i = j;
+ }
+ }
+
+ close(f);
+ bt->result[sizeof(bt->result) - 1] = '\n';
+ if (i && bt->result[i - 1] == '\n')
+ i--;
+ debug1("runbacktick: finished, %d bytes\n", i);
+ bt->result[i] = 0;
+ backtick_filter(bt);
+ (void)time(&now2);
+ bt->bestbefore = now2 + bt->lifespan;
+ return bt->result;
+}
+
+int AddWinMsgRend(const char *str, int r)
+{
+ if (winmsg_numrend >= MAX_WINMSG_REND || str < winmsg_buf || str >= winmsg_buf + MAXSTR)
+ return -1;
+
+ winmsg_rend[winmsg_numrend] = r;
+ winmsg_rendpos[winmsg_numrend] = str - winmsg_buf;
+ winmsg_numrend++;
+ return 0;
+}
+
+char *MakeWinMsgEv(char *str, struct win *win, int esc, int padlen, struct event *ev, int rec)
+{
+ static int tick;
+ char *s = str;
+ register char *p = winmsg_buf;
+ register int ctrl;
+ struct timeval now;
+ struct tm *tm;
+ int l, i, r;
+ int num;
+ int zeroflg;
+ int longflg;
+ int minusflg;
+ int plusflg;
+ int qmflag = 0, omflag = 0, qmnumrend = 0;
+ char *qmpos = 0;
+ int numpad = 0;
+ int lastpad = 0;
+ int truncpos = -1;
+ int truncper = 0;
+ int trunclong = 0;
+ struct backtick *bt = NULL;
+
+ if (winmsg_numrend >= 0)
+ winmsg_numrend = 0;
+ else
+ winmsg_numrend = -winmsg_numrend;
+
+ tick = 0;
+ tm = 0;
+ ctrl = 0;
+ gettimeofday(&now, NULL);
+ for (; *s && (l = winmsg_buf + MAXSTR - 1 - p) > 0; s++, p++) {
+ *p = *s;
+ if (ctrl) {
+ ctrl = 0;
+ if (*s != '^' && *s >= 64)
+ *p &= 0x1f;
+ continue;
+ }
+
+ if (*s != esc) {
+ if (esc == '%') {
+ switch (*s) {
+#if 0
+ case '~':
+ *p = BELL;
+ break;
+#endif
+ case '^':
+ ctrl = 1;
+ *p-- = '^';
+ break;
+
+ default:
+ break;
+ }
+ }
+ continue;
+ }
+
+ if (*++s == esc) /* double escape ? */
+ continue;
+
+ if ((plusflg = *s == '+') != 0)
+ s++;
+
+ if ((minusflg = *s == '-') != 0)
+ s++;
+
+ if ((zeroflg = *s == '0') != 0)
+ s++;
+
+ num = 0;
+ while(*s >= '0' && *s <= '9')
+ num = num * 10 + (*s++ - '0');
+
+ if ((longflg = *s == 'L') != 0)
+ s++;
+
+ switch (*s) {
+ case '?':
+ p--;
+ if (qmpos) {
+ if ((!qmflag && !omflag) || omflag == 1){
+ p = qmpos;
+ if (qmnumrend < winmsg_numrend)
+ winmsg_numrend = qmnumrend;
+ }
+ qmpos = 0;
+ break;
+ }
+ qmpos = p;
+ qmnumrend = winmsg_numrend;
+ qmflag = omflag = 0;
+ break;
+
+ case ':':
+ p--;
+ if (!qmpos)
+ break;
+ if (qmflag && omflag != 1) {
+ omflag = 1;
+ qmpos = p;
+ qmnumrend = winmsg_numrend;
+ }
+ else {
+ p = qmpos;
+ if (qmnumrend < winmsg_numrend)
+ winmsg_numrend = qmnumrend;
+ omflag = -1;
+ }
+ break;
+
+ case 'd': case 'D': case 'm': case 'M': case 'y': case 'Y':
+ case 'a': case 'A': case 's': case 'c': case 'C':
+
+ if (l < 4)
+ break;
+ if (tm == 0) {
+ time_t nowsec = now.tv_sec;
+ tm = localtime(&nowsec);
+ }
+
+ qmflag = 1;
+ if (!tick || tick > 3600)
+ tick = 3600;
+
+ switch (*s) {
+ case 'd':
+ sprintf(p, "%02d", tm->tm_mday % 100);
+ break;
+
+ case 'D':
+#ifdef USE_LOCALE
+ strftime(p, l, (longflg ? "%A" : "%a"), tm);
+#else
+ sprintf(p, "%3.3s", days + 3 * tm->tm_wday);
+#endif
+ break;
+
+ case 'm':
+ sprintf(p, "%02d", tm->tm_mon + 1);
+ break;
+
+ case 'M':
+#ifdef USE_LOCALE
+ strftime(p, l, (longflg ? "%B" : "%b"), tm);
+#else
+ sprintf(p, "%3.3s", months + 3 * tm->tm_mon);
+#endif
+ break;
+
+ case 'y':
+ sprintf(p, "%02d", tm->tm_year % 100);
+ break;
+
+ case 'Y':
+ sprintf(p, "%04d", tm->tm_year + 1900);
+ break;
+
+ case 'a':
+ sprintf(p, tm->tm_hour >= 12 ? "pm" : "am");
+ break;
+
+ case 'A':
+ sprintf(p, tm->tm_hour >= 12 ? "PM" : "AM");
+ break;
+
+ case 's':
+ sprintf(p, "%02d", tm->tm_sec);
+ tick = 1;
+ break;
+
+ case 'c':
+ sprintf(p, zeroflg ? "%02d:%02d" : "%2d:%02d", tm->tm_hour, tm->tm_min);
+ if (!tick || tick > 60)
+ tick = 60;
+ break;
+
+ case 'C':
+ sprintf(p, zeroflg ? "%02d:%02d" : "%2d:%02d", (tm->tm_hour + 11) % 12 + 1, tm->tm_min);
+ if (!tick || tick > 60)
+ tick = 60;
+ break;
+
+ default:
+ break;
+ }
+
+ p += strlen(p) - 1;
+ break;
+
+ case 'X': case 'x':
+ *p = 0;
+ for (i = 0; win && win->w_cmdargs[i]; i++) {
+ if (l < strlen(win->w_cmdargs[i]) + 1)
+ break;
+ sprintf(p, i ? " %s" : "%s", win->w_cmdargs[i]);
+ l -= strlen(p);
+ p += strlen(p);
+ if (i == 0 && *s == 'X')
+ break;
+ }
+ p--;
+ break;
+
+ case 'l':
+#ifdef LOADAV
+ *p = 0;
+ if (l > 20)
+ AddLoadav(p);
+ if (*p) {
+ qmflag = 1;
+ p += strlen(p) - 1;
+ }
+ else
+ *p = '?';
+
+ if (!tick || tick > 60)
+ tick = 60;
+#else
+ *p = '?';
+#endif
+ p += strlen(p) - 1;
+ break;
+
+ case '`':
+ case 'h':
+ if (rec >= 10 || (*s == 'h' && (win == 0 || win->w_hstatus == 0 || *win->w_hstatus == 0))) {
+ p--;
+ break;
+ }
+ if (*s == '`') {
+ for (bt = backticks; bt; bt = bt->next)
+ if (bt->num == num)
+ break;
+ if (bt == 0) {
+ p--;
+ break;
+ }
+ }
+ {
+ char savebuf[sizeof(winmsg_buf)];
+ int oldtick = tick;
+ int oldnumrend = winmsg_numrend;
+
+ *p = 0;
+ strcpy(savebuf, winmsg_buf);
+ winmsg_numrend = -winmsg_numrend;
+ MakeWinMsgEv(*s == 'h' ?
+ win->w_hstatus : runbacktick(bt, &oldtick, now.tv_sec), win, '\005', 0, (struct event *)0, rec + 1);
+ debug2("oldtick=%d tick=%d\n", oldtick, tick);
+ if (!tick || oldtick < tick)
+ tick = oldtick;
+ if ((int)strlen(winmsg_buf) < l)
+ strcat(savebuf, winmsg_buf);
+ strcpy(winmsg_buf, savebuf);
+ while (oldnumrend < winmsg_numrend)
+ winmsg_rendpos[oldnumrend++] += p - winmsg_buf;
+ if (*p)
+ qmflag = 1;
+ p += strlen(p) - 1;
+ }
+ break;
+
+ case 'w':
+ case 'W':
+ {
+ struct win *oldfore = 0;
+ char *ss;
+ if (display) {
+ oldfore = D_fore;
+ D_fore = win;
+ }
+ ss = AddWindows(p, l - 1, (*s == 'w' ? 0 : 1) |
+ (longflg ? 0 : 2) | (plusflg ? 4 : 0) |
+ (minusflg ? 8 : 0), win ? win->w_number : -1);
+ if (display)
+ D_fore = oldfore;
+ }
+ if (*p)
+ qmflag = 1;
+ p += strlen(p) - 1;
+ break;
+
+ case 'u':
+ *p = 0;
+ if (win)
+ AddOtherUsers(p, l - 1, win);
+ if (*p)
+ qmflag = 1;
+ p += strlen(p) - 1;
+ break;
+
+ case 'f':
+ *p = 0;
+ if (win)
+ AddWindowFlags(p, l - 1, win);
+ if (*p)
+ qmflag = 1;
+ p += strlen(p) - 1;
+ break;
+
+ case 't':
+ *p = 0;
+ if (win && (int)strlen(win->w_title) < l) {
+ strcpy(p, win->w_title);
+ if (*p)
+ qmflag = 1;
+ }
+ p += strlen(p) - 1;
+ break;
+
+ case '{':
+ {
+ char rbuf[128];
+ s++;
+
+ for (i = 0; i < 127; i++)
+ if (s[i] && s[i] != '}')
+ rbuf[i] = s[i];
+ else
+ break;
+
+ if (s[i] == '}' && winmsg_numrend < MAX_WINMSG_REND) {
+ r = -1;
+ rbuf[i] = 0;
+ debug1("MakeWinMsg attrcolor %s\n", rbuf);
+
+ if (i != 1 || rbuf[0] != '-')
+ r = ParseAttrColor(rbuf, (char *)0, 0);
+ if (r != -1 || (i == 1 && rbuf[0] == '-')) {
+ winmsg_rend[winmsg_numrend] = r;
+ winmsg_rendpos[winmsg_numrend] = p - winmsg_buf;
+ winmsg_numrend++;
+ }
+ }
+ s += i;
+ p--;
+ }
+ break;
+
+ case 'H':
+ *p = 0;
+ if ((int)strlen(HostName) < l) {
+ strcpy(p, HostName);
+ if (*p)
+ qmflag = 1;
+ }
+ p += strlen(p) - 1;
+ break;
+
+ case 'S':
+ {
+ char *session_name;
+ *p = 0;
+ session_name = strchr(SockName, '.') + 1;
+ if ((int)strlen(session_name) < l) {
+ strcpy(p, session_name);
+ if (*p)
+ qmflag = 1;
+ }
+ p += strlen(p) - 1;
+ }
+ break;
+
+ case 'p':
+ {
+ sprintf(p, "%d", (plusflg && display) ? D_userpid : getpid());
+ p += strlen(p) - 1;
+ }
+ break;
+
+ case 'F':
+ p--;
+ /* small hack */
+ if (display && ((ev && ev == &D_forecv->c_captev) || (!ev && win && win == D_fore)))
+ minusflg = !minusflg;
+ if (minusflg)
+ qmflag = 1;
+ break;
+
+ case 'P':
+ p--;
+#ifdef COPY_PASTE
+ if (display && ev && ev != &D_hstatusev) { /* Hack */
+ /* Is the layer in the current canvas in copy mode? */
+ struct canvas *cv = (struct canvas *)ev->data;
+ if (ev == &cv->c_captev && cv->c_layer->l_layfn == &MarkLf)
+ qmflag = 1;
+ }
+#endif
+ break;
+
+
+ case 'E':
+ p--;
+ if (display && D_ESCseen)
+ qmflag = 1;
+ break;
+
+ case '>':
+ truncpos = p - winmsg_buf;
+ truncper = num > 100 ? 100 : num;
+ trunclong = longflg;
+ p--;
+ break;
+
+ case '=':
+ case '<':
+ *p = ' ';
+ if (num || zeroflg || plusflg || longflg || (*s != '=')) {
+ /* expand all pads */
+ if (minusflg) {
+ num = (plusflg ? lastpad : padlen) - num;
+ if (!plusflg && padlen == 0)
+ num = p - winmsg_buf;
+ plusflg = 0;
+ }
+ else if (!zeroflg) {
+ if (*s != '=' && num == 0 && !plusflg)
+ num = 100;
+ if (num > 100)
+ num = 100;
+ if (padlen == 0)
+ num = p - winmsg_buf;
+ else
+ num = (padlen - (plusflg ? lastpad : 0)) * num / 100;
+ }
+
+ if (num < 0)
+ num = 0;
+
+ if (plusflg)
+ num += lastpad;
+
+ if (num > MAXSTR - 1)
+ num = MAXSTR - 1;
+
+ if (numpad)
+ p = pad_expand(winmsg_buf, p, numpad, num);
+
+ numpad = 0;
+ if (p - winmsg_buf > num && !longflg) {
+ int left, trunc;
+ if (truncpos == -1) {
+ truncpos = lastpad;
+ truncper = 0;
+ }
+
+ trunc = lastpad + truncper * (num - lastpad) / 100;
+ if (trunc > num)
+ trunc = num;
+ if (trunc < lastpad)
+ trunc = lastpad;
+ left = truncpos - trunc;
+ if (left > p - winmsg_buf - num)
+ left = p - winmsg_buf - num;
+ debug1("lastpad = %d, ", lastpad);
+ debug3("truncpos = %d, trunc = %d, left = %d\n", truncpos, trunc, left);
+
+ if (left > 0) {
+ if (left + lastpad > p - winmsg_buf)
+ left = p - winmsg_buf - lastpad;
+ if (p - winmsg_buf - lastpad - left > 0)
+ bcopy(winmsg_buf + lastpad + left, winmsg_buf + lastpad, p - winmsg_buf - lastpad - left);
+ p -= left;
+ r = winmsg_numrend;
+ while (r && winmsg_rendpos[r - 1] > lastpad) {
+ r--;
+ winmsg_rendpos[r] -= left;
+ if (winmsg_rendpos[r] < lastpad)
+ winmsg_rendpos[r] = lastpad;
+ }
+
+ if (trunclong) {
+ if (p - winmsg_buf > lastpad)
+ winmsg_buf[lastpad] = '.';
+ if (p - winmsg_buf > lastpad + 1)
+ winmsg_buf[lastpad + 1] = '.';
+ if (p - winmsg_buf > lastpad + 2)
+ winmsg_buf[lastpad + 2] = '.';
+ }
+ }
+
+ if (p - winmsg_buf > num) {
+ p = winmsg_buf + num;
+ if (trunclong) {
+ if (num - 1 >= lastpad)
+ p[-1] = '.';
+ if (num - 2 >= lastpad)
+ p[-2] = '.';
+ if (num - 3 >= lastpad)
+ p[-3] = '.';
+ }
+ r = winmsg_numrend;
+ while (r && winmsg_rendpos[r - 1] > num)
+ winmsg_rendpos[--r] = num;
+ }
+ truncpos = -1;
+ trunclong = 0;
+ if (lastpad > p - winmsg_buf)
+ lastpad = p - winmsg_buf;
+ debug1("lastpad now %d\n", lastpad);
+ }
+
+ if (*s == '=') {
+ while (p - winmsg_buf < num)
+ *p++ = ' ';
+ lastpad = p - winmsg_buf;
+ truncpos = -1;
+ trunclong = 0;
+ debug1("lastpad2 now %d\n", lastpad);
+ }
+ p--;
+ }
+ else if (padlen) {
+ *p = 127; /* internal pad representation */
+ numpad++;
+ }
+ break;
+
+ case 'n':
+ s++;
+ /* FALLTHROUGH */
+
+ default:
+ s--;
+ if (l > 10 + num) {
+ if (num == 0)
+ num = 1;
+ if (!win)
+ sprintf(p, "%*s", num, num > 1 ? "--" : "-");
+ else
+ sprintf(p, "%*d", num, win->w_number);
+ qmflag = 1;
+ p += strlen(p) - 1;
+ }
+ break;
+ }
+ }
+
+ if (qmpos && !qmflag)
+ p = qmpos + 1;
+ *p = '\0';
+ if (numpad) {
+ if (padlen > MAXSTR - 1)
+ padlen = MAXSTR - 1;
+ p = pad_expand(winmsg_buf, p, numpad, padlen);
+ }
+ if (ev) {
+ evdeq(ev); /* just in case */
+ ev->timeout.tv_sec = 0;
+ ev->timeout.tv_usec = 0;
+ }
+ if (ev && tick) {
+ now.tv_usec = 100000;
+ if (tick == 1)
+ now.tv_sec++;
+ else
+ now.tv_sec += tick - (now.tv_sec % tick);
+ ev->timeout = now;
+ debug2("NEW timeout %d %d\n", ev->timeout.tv_sec, tick);
+ }
+ return winmsg_buf;
+}
+
+
+char *MakeWinMsg(char *s, struct win *win, int esc)
+{
+ return MakeWinMsgEv(s, win, esc, 0, (struct event *)0, 0);
+}
+
+void PutWinMsg(char *s, int start, int max)
+{
+ int i, p, l, r, n;
+ struct mchar rend;
+ struct mchar rendstack[MAX_WINMSG_REND];
+ int rendstackn = 0;
+
+ if (s != winmsg_buf) {
+ /* sorry, no fancy coloring available */
+ debug1("PutWinMsg %s plain\n", s);
+ l = strlen(s);
+ if (l > max)
+ l = max;
+ l -= start;
+ s += start;
+ while (l-- > 0)
+ PUTCHARLP(*s++);
+ return;
+ }
+ rend = D_rend;
+ p = 0;
+ l = strlen(s);
+ debug2("PutWinMsg %s start attr %x\n", s, rend.attr);
+ for (i = 0; i < winmsg_numrend && max > 0; i++) {
+ if (p > winmsg_rendpos[i] || winmsg_rendpos[i] > l)
+ break;
+ if (p < winmsg_rendpos[i]) {
+ n = winmsg_rendpos[i] - p;
+ if (n > max)
+ n = max;
+ max -= n;
+ p += n;
+ while(n-- > 0) {
+ if (start-- > 0)
+ s++;
+ else
+ PUTCHARLP(*s++);
+ }
+ }
+
+ r = winmsg_rend[i];
+ if (r == -1) {
+ if (rendstackn > 0)
+ rend = rendstack[--rendstackn];
+ }
+ else {
+ rendstack[rendstackn++] = rend;
+ ApplyAttrColor(r, &rend);
+ }
+
+ SetRendition(&rend);
+ }
+ if (p < l){
+ n = l - p;
+ if (n > max)
+ n = max;
+ while(n-- > 0) {
+ if (start-- > 0)
+ s++;
+ else
+ PUTCHARLP(*s++);
+ }
+ }
+}
+
+#ifdef DEBUG
+static void fds1(int i, int j)
+{
+ while (i < j) {
+ debug1("%d ", i);
+ i++;
+ }
+ if ((j = open("/dev/null", 0)) >= 0) {
+ fds1(i + 1, j);
+ close(j);
+ }
+ else {
+ while (dup(++i) < 0 && errno != EBADF)
+ debug1("%d ", i);
+ debug1(" [%d]\n", i);
+ }
+}
+
+static void fds()
+{
+ debug("fds: ");
+ fds1(-1, -1);
+}
+#endif
+
+static void serv_read_fn(struct event *ev, char *data)
+{
+ debug("Knock - knock!\n");
+ ReceiveMsg();
+}
+
+static void serv_select_fn(struct event *ev, char *data)
+{
+ struct win *p;
+ debug("serv_select_fn called\n");
+ /* XXX: messages?? */
+ if (GotSigChld)
+ SigChldHandler();
+
+ if (InterruptPlease) {
+ debug("Backend received interrupt\n");
+ /* This approach is rather questionable in a multi-display
+ * environment */
+ if (fore && displays) {
+#if defined(TERMIO) || defined(POSIX)
+ char ibuf = displays->d_OldMode.tio.c_cc[VINTR];
+#else
+ char ibuf = displays->d_OldMode.m_tchars.t_intrc;
+#endif
+
+
+#ifdef PSEUDOS
+ write(W_UWP(fore) ? fore->w_pwin->p_ptyfd : fore->w_ptyfd, &ibuf, 1);
+ debug1("Backend wrote interrupt to %d", fore->w_number);
+ debug1("%s\n", W_UWP(fore) ? " (pseudowin)" : "");
+#else
+ write(fore->w_ptyfd, &ibuf, 1);
+ debug1("Backend wrote interrupt to %d\n", fore->w_number);
+#endif
+ }
+ InterruptPlease = 0;
+ }
+
+ for (p = windows; p; p = p->w_next){
+ if (p->w_bell == BELL_FOUND || p->w_bell == BELL_VISUAL) {
+ struct canvas *cv;
+ int visual = p->w_bell == BELL_VISUAL || visual_bell;
+ p->w_bell = BELL_ON;
+ for (display = displays; display; display = display->d_next) {
+ for (cv = D_cvlist; cv; cv = cv->c_next)
+ if (cv->c_layer->l_bottom == &p->w_layer)
+ break;
+
+ if (cv == 0) {
+ p->w_bell = BELL_DONE;
+ Msg(0, "%s", MakeWinMsg(BellString, p, '%'));
+ }
+ else if (visual && !D_VB && (!D_status || !D_status_bell)) {
+ Msg(0, "%s", VisualBellString);
+
+ if (D_status) {
+ D_status_bell = 1;
+ debug1("using vbell timeout %d\n", VBellWait);
+ SetTimeout(&D_statusev, VBellWait );
+ }
+ }
+ }
+
+ /* don't annoy the user with two messages */
+ if (p->w_monitor == MON_FOUND)
+ p->w_monitor = MON_DONE;
+ WindowChanged(p, 'f');
+ }
+
+ if (p->w_monitor == MON_FOUND) {
+ struct canvas *cv;
+ p->w_monitor = MON_ON;
+ for (display = displays; display; display = display->d_next) {
+ for (cv = D_cvlist; cv; cv = cv->c_next)
+ if (cv->c_layer->l_bottom == &p->w_layer)
+ break;
+ if (cv)
+ continue; /* user already sees window */
+
+#ifdef MULTIUSER
+ if (!(ACLBYTE(p->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id)))
+ continue; /* user doesn't care */
+#endif
+
+ Msg(0, "%s", MakeWinMsg(ActivityString, p, '%'));
+ p->w_monitor = MON_DONE;
+ }
+ WindowChanged(p, 'f');
+ }
+
+ if (p->w_silence == SILENCE_FOUND) {
+ /* Unset the flag if the user switched to this window. */
+ if (p->w_layer.l_cvlist) {
+ p->w_silence = SILENCE_ON;
+ WindowChanged(p, 'f');
+ }
+ }
+ }
+
+ for (display = displays; display; display = display->d_next) {
+ struct canvas *cv;
+ if (D_status == STATUS_ON_WIN)
+ continue;
+ /* XXX: should use display functions! */
+ for (cv = D_cvlist; cv; cv = cv->c_next) {
+ int lx, ly;
+
+ /* normalize window, see resize.c */
+ lx = cv->c_layer->l_x;
+ ly = cv->c_layer->l_y;
+ if (lx == cv->c_layer->l_width)
+ lx--;
+ if (ly + cv->c_yoff < cv->c_ys) {
+ int i, n = cv->c_ys - (ly + cv->c_yoff);
+ cv->c_yoff = cv->c_ys - ly;
+ RethinkViewportOffsets(cv);
+ if (n > cv->c_layer->l_height)
+ n = cv->c_layer->l_height;
+ CV_CALL(cv,
+ LScrollV(flayer, -n, 0, flayer->l_height - 1, 0);
+ LayRedisplayLine(-1, -1, -1, 1);
+ for (i = 0; i < n; i++)
+ LayRedisplayLine(i, 0, flayer->l_width - 1, 1);
+ if (cv == cv->c_display->d_forecv)
+ LaySetCursor();
+ );
+ }
+ else if (ly + cv->c_yoff > cv->c_ye) {
+ int i, n = ly + cv->c_yoff - cv->c_ye;
+ cv->c_yoff = cv->c_ye - ly;
+ RethinkViewportOffsets(cv);
+ if (n > cv->c_layer->l_height)
+ n = cv->c_layer->l_height;
+ CV_CALL(cv,
+ LScrollV(flayer, n, 0, cv->c_layer->l_height - 1, 0);
+ LayRedisplayLine(-1, -1, -1, 1);
+ for (i = 0; i < n; i++)
+ LayRedisplayLine(i + flayer->l_height - n, 0, flayer->l_width - 1, 1);
+ if (cv == cv->c_display->d_forecv)
+ LaySetCursor();
+ );
+ }
+ if (lx + cv->c_xoff < cv->c_xs) {
+ int i, n = cv->c_xs - (lx + cv->c_xoff);
+ if (n < (cv->c_xe - cv->c_xs + 1) / 2)
+ n = (cv->c_xe - cv->c_xs + 1) / 2;
+ if (cv->c_xoff + n > cv->c_xs)
+ n = cv->c_xs - cv->c_xoff;
+ cv->c_xoff += n;
+ RethinkViewportOffsets(cv);
+ if (n > cv->c_layer->l_width)
+ n = cv->c_layer->l_width;
+ CV_CALL(cv,
+ LayRedisplayLine(-1, -1, -1, 1);
+ for (i = 0; i < flayer->l_height; i++) {
+ LScrollH(flayer, -n, i, 0, flayer->l_width - 1, 0, 0);
+ LayRedisplayLine(i, 0, n - 1, 1);
+ }
+ if (cv == cv->c_display->d_forecv)
+ LaySetCursor();
+ );
+ }
+ else if (lx + cv->c_xoff > cv->c_xe) {
+ int i, n = lx + cv->c_xoff - cv->c_xe;
+ if (n < (cv->c_xe - cv->c_xs + 1) / 2)
+ n = (cv->c_xe - cv->c_xs + 1) / 2;
+ if (cv->c_xoff - n + cv->c_layer->l_width - 1 < cv->c_xe)
+ n = cv->c_xoff + cv->c_layer->l_width - 1 - cv->c_xe;
+ cv->c_xoff -= n;
+ RethinkViewportOffsets(cv);
+ if (n > cv->c_layer->l_width)
+ n = cv->c_layer->l_width;
+ CV_CALL(cv,
+ LayRedisplayLine(-1, -1, -1, 1);
+ for (i = 0; i < flayer->l_height; i++) {
+ LScrollH(flayer, n, i, 0, flayer->l_width - 1, 0, 0);
+ LayRedisplayLine(i, flayer->l_width - n, flayer->l_width - 1, 1);
+ }
+ if (cv == cv->c_display->d_forecv)
+ LaySetCursor();
+ );
+ }
+ }
+ }
+ for (display = displays; display; display = display->d_next) {
+ if (D_status == STATUS_ON_WIN || D_cvlist == 0 || D_cvlist->c_next == 0)
+ continue;
+ debug1("serv_select_fn: Restore on cv %#x\n", (int)D_forecv);
+ CV_CALL(D_forecv, LayRestore();LaySetCursor());
+ }
+}
+
+static void logflush_fn(struct event *ev, char *data)
+{
+ struct win *p;
+ char *buf;
+ int n;
+
+ if (!islogfile(NULL))
+ return; /* no more logfiles */
+ logfflush(NULL);
+ n = log_flush ? log_flush : (logtstamp_after + 4) / 5;
+
+ if (n) {
+ SetTimeout(ev, n * 1000);
+ evenq(ev); /* re-enqueue ourself */
+ }
+
+ if (!logtstamp_on)
+ return;
+
+ /* write fancy time-stamp */
+ for (p = windows; p; p = p->w_next) {
+ if (!p->w_log)
+ continue;
+ p->w_logsilence += n;
+ if (p->w_logsilence < logtstamp_after)
+ continue;
+ if (p->w_logsilence - n >= logtstamp_after)
+ continue;
+ buf = MakeWinMsg(logtstamp_string, p, '%');
+ logfwrite(p->w_log, buf, strlen(buf));
+ }
+}
+
+/*
+ * Interprets ^?, ^@ and other ^-control-char notation.
+ * Interprets \ddd octal notation
+ *
+ * The result is placed in *cp, p is advanced behind the parsed expression and
+ * returned.
+ */
+static char *ParseChar(char *p, char *cp)
+{
+ if (*p == 0)
+ return 0;
+
+ if (*p == '^' && p[1]) {
+ if (*++p == '?')
+ *cp = '\177';
+ else if (*p >= '@')
+ *cp = Ctrl(*p);
+ else
+ return 0;
+ ++p;
+ }
+ else if (*p == '\\' && *++p <= '7' && *p >= '0') {
+ *cp = 0;
+ do
+ *cp = *cp * 8 + *p - '0';
+ while (*++p <= '7' && *p >= '0');
+ }
+ else
+ *cp = *p++;
+ return p;
+}
+
+static int ParseEscape(char *p)
+{
+ unsigned char buf[2];
+
+ if (*p == 0)
+ SetEscape((struct acluser *)0, -1, -1);
+ else {
+ if ((p = ParseChar(p, (char *)buf)) == NULL ||
+ (p = ParseChar(p, (char *)buf+1)) == NULL || *p)
+ return -1;
+ SetEscape((struct acluser *)0, buf[0], buf[1]);
+ }
+ return 0;
+}
+
+void SetTtyname(bool fatal, struct stat *st)
+{
+ int ret;
+ int saved_errno = 0;
+
+ attach_tty_is_in_new_ns = false;
+ memset(&attach_tty_name_in_ns, 0, sizeof(attach_tty_name_in_ns));
+
+ errno = 0;
+ attach_tty = ttyname(0);
+ if (!attach_tty) {
+ if (errno == ENODEV) {
+ saved_errno = errno;
+ attach_tty = "/proc/self/fd/0";
+ attach_tty_is_in_new_ns = true;
+ ret = readlink(attach_tty, attach_tty_name_in_ns, sizeof(attach_tty_name_in_ns));
+ if (ret < 0 || (size_t)ret >= sizeof(attach_tty_name_in_ns))
+ Panic(0, "Bad tty '%s'", attach_tty);
+ } else if (fatal) {
+ Panic(0, "Must be connected to a terminal.");
+ } else {
+ attach_tty = "";
+ }
+ }
+
+ if (attach_tty && strcmp(attach_tty, "")) {
+ if (stat(attach_tty, st))
+ Panic(errno, "Cannot access '%s'", attach_tty);
+
+ if (strlen(attach_tty) >= MAXPATHLEN)
+ Panic(0, "TtyName too long - sorry.");
+
+ /* Only call CheckTtyname() if the device does not exist in
+ * another namespace.
+ */
+ if (saved_errno != ENODEV && CheckTtyname(attach_tty))
+ Panic(0, "Bad tty '%s'", attach_tty);
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-12 15:32:46 +0000