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