src/screen.c

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