src/window.c

   1 /* Copyright (c) 1993-2002
   2  *      Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
   3  *      Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
   4  * Copyright (c) 1987 Oliver Laumann
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2, or (at your option)
   9  * any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program (see the file COPYING); if not, write to the
  18  * Free Software Foundation, Inc.,
  19  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
  20  *
  21  ****************************************************************
  22  */
  23
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <signal.h>
  27 #include <fcntl.h>
  28 #ifndef sun
  29 # include <sys/ioctl.h>
  30 #endif
  31
  32 #include "config.h"
  33
  34 #include "screen.h"
  35 #include "extern.h"
  36 #include "logfile.h"    /* logfopen() */
  37
  38 extern struct display *displays, *display;
  39 extern struct win *windows, *fore, *wtab[], *console_window;
  40 extern char *ShellArgs[];
  41 extern char *ShellProg;
  42 extern char screenterm[];
  43 extern char *screenlogfile;
  44 extern char HostName[];
  45 extern int TtyMode;
  46 extern int SilenceWait;
  47 extern int real_uid, real_gid, eff_uid, eff_gid;
  48 extern char Termcap[];
  49 extern char **NewEnv;
  50 extern int visual_bell, maxwin;
  51 extern struct event logflushev;
  52 extern int log_flush, logtstamp_after;
  53 extern int ZombieKey_destroy, ZombieKey_resurrect, ZombieKey_onerror;
  54 extern struct layer *flayer;
  55 extern int maxusercount;
  56 extern int pty_preopen;
  57 #ifdef ZMODEM
  58 extern int zmodem_mode;
  59 extern struct mchar mchar_blank;
  60 extern char *zmodem_sendcmd;
  61 extern char *zmodem_recvcmd;
  62 #endif
  63
  64 #if defined(TIOCSWINSZ) || defined(TIOCGWINSZ)
  65 extern struct winsize glwz;
  66 #endif
  67
  68 #ifdef O_NOCTTY
  69 extern int separate_sids;
  70 #endif
  71
  72 static void WinProcess __P((char **, int *));
  73 static void WinRedisplayLine __P((int, int, int, int));
  74 static void WinClearLine __P((int, int, int, int));
  75 static int  WinRewrite __P((int, int, int, struct mchar *, int));
  76 static int  WinResize __P((int, int));
  77 static void WinRestore __P((void));
  78 static int  DoAutolf __P((char *, int *, int));
  79 static void ZombieProcess __P((char **, int *));
  80 static void win_readev_fn __P((struct event *, char *));
  81 static void win_writeev_fn __P((struct event *, char *));
  82 static int  muchpending __P((struct win *, struct event *));
  83 #ifdef COPY_PASTE
  84 static void paste_slowev_fn __P((struct event *, char *));
  85 #endif
  86 #ifdef PSEUDOS
  87 static void pseu_readev_fn __P((struct event *, char *));
  88 static void pseu_writeev_fn __P((struct event *, char *));
  89 #endif
  90 static void win_silenceev_fn __P((struct event *, char *));
  91
  92 static int  OpenDevice __P((char **, int, int *, char **));
  93 static int  ForkWindow __P((struct win *, char **, char *));
  94 #ifdef ZMODEM
  95 static void zmodem_found __P((struct win *, int, char *, int));
  96 static void zmodem_fin __P((char *, int, char *));
  97 static int  zmodem_parse __P((struct win *, char *, int));
  98 #endif
  99
 100
 101
 102 int VerboseCreate = 0;          /* XXX move this to user.h */
 103
 104 char DefaultShell[] = "/bin/sh";
 105 static char DefaultPath[] = ":/usr/ucb:/bin:/usr/bin";
 106
 107 /* keep this in sync with the structure definition in window.h */
 108 struct NewWindow nwin_undef   =
 109 {
 110   -1,           /* StartAt */
 111   (char *)0,    /* aka */
 112   (char **)0,   /* args */
 113   (char *)0,    /* dir */
 114   (char *)0,    /* term */
 115   -1,           /* aflag */
 116   -1,           /* flowflag */
 117   -1,           /* lflag */
 118   -1,           /* histheight */
 119   -1,           /* monitor */
 120   -1,           /* wlock */
 121   -1,           /* silence */
 122   -1,           /* wrap */
 123   -1,           /* logging */
 124   -1,           /* slowpaste */
 125   -1,           /* gr */
 126   -1,           /* c1 */
 127   -1,           /* bce */
 128   -1,           /* encoding */
 129   (char *)0,    /* hstatus */
 130   (char *)0     /* charset */
 131 };
 132
 133 struct NewWindow nwin_default =
 134 {
 135   0,            /* StartAt */
 136   0,            /* aka */
 137   ShellArgs,    /* args */
 138   0,            /* dir */
 139   screenterm,   /* term */
 140   0,            /* aflag */
 141   1*FLOW_NOW,   /* flowflag */
 142   LOGINDEFAULT, /* lflag */
 143   DEFAULTHISTHEIGHT,    /* histheight */
 144   MON_OFF,      /* monitor */
 145   WLOCK_OFF,    /* wlock */
 146   0,            /* silence */
 147   1,            /* wrap */
 148   0,            /* logging */
 149   0,            /* slowpaste */
 150   0,            /* gr */
 151   1,            /* c1 */
 152   0,            /* bce */
 153   0,            /* encoding */
 154   (char *)0,    /* hstatus */
 155   (char *)0     /* charset */
 156 };
 157
 158 struct NewWindow nwin_options;
 159
 160 static int const_IOSIZE = IOSIZE;
 161 static int const_one = 1;
 162
 163 void
 164 nwin_compose(def, new, res)
 165 struct NewWindow *def, *new, *res;
 166 {
 167 #define COMPOSE(x) res->x = new->x != nwin_undef.x ? new->x : def->x
 168   COMPOSE(StartAt);
 169   COMPOSE(aka);
 170   COMPOSE(args);
 171   COMPOSE(dir);
 172   COMPOSE(term);
 173   COMPOSE(aflag);
 174   COMPOSE(flowflag);
 175   COMPOSE(lflag);
 176   COMPOSE(histheight);
 177   COMPOSE(monitor);
 178   COMPOSE(wlock);
 179   COMPOSE(silence);
 180   COMPOSE(wrap);
 181   COMPOSE(Lflag);
 182   COMPOSE(slow);
 183   COMPOSE(gr);
 184   COMPOSE(c1);
 185   COMPOSE(bce);
 186   COMPOSE(encoding);
 187   COMPOSE(hstatus);
 188   COMPOSE(charset);
 189 #undef COMPOSE
 190 }
 191
 192 /*****************************************************************
 193  *
 194  *  The window layer functions
 195  */
 196
 197 struct LayFuncs WinLf =
 198 {
 199   WinProcess,
 200   0,
 201   WinRedisplayLine,
 202   WinClearLine,
 203   WinRewrite,
 204   WinResize,
 205   WinRestore
 206 };
 207
 208 static int
 209 DoAutolf(buf, lenp, fr)
 210 char *buf;
 211 int *lenp;
 212 int fr;
 213 {
 214   char *p;
 215   int len = *lenp;
 216   int trunc = 0;
 217
 218   for (p = buf; len > 0; p++, len--)
 219     {
 220       if (*p != '\r')
 221         continue;
 222       if (fr-- <= 0)
 223         {
 224           trunc++;
 225           len--;
 226         }
 227       if (len == 0)
 228         break;
 229       bcopy(p, p + 1, len++);
 230       p[1] = '\n';
 231     }
 232   *lenp = p - buf;
 233   return trunc;
 234 }
 235
 236 static void
 237 WinProcess(bufpp, lenp)
 238 char **bufpp;
 239 int *lenp;
 240 {
 241   int l2 = 0, f, *ilen, l = *lenp, trunc;
 242   char *ibuf;
 243
 244   debug1("WinProcess: %d bytes\n", *lenp);
 245   fore = (struct win *)flayer->l_data;
 246
 247   if (fore->w_type == W_TYPE_GROUP)
 248     {
 249       *bufpp += *lenp;
 250       *lenp = 0;
 251       return;
 252     }
 253   if (fore->w_ptyfd < 0)        /* zombie? */
 254     {
 255       ZombieProcess(bufpp, lenp);
 256       return;
 257     }
 258 #ifdef MULTIUSER
 259  /* a pending writelock is this:
 260   * fore->w_wlock == WLOCK_AUTO, fore->w_wlockuse = NULL
 261   * The user who wants to use this window next, will get the lock, if he can.
 262   */
 263  if (display && fore->w_wlock == WLOCK_AUTO &&
 264      !fore->w_wlockuser && !AclCheckPermWin(D_user, ACL_WRITE, fore))
 265    {
 266      fore->w_wlockuser = D_user;
 267      debug2("window %d: pending writelock grabbed by user %s\n",
 268             fore->w_number, fore->w_wlockuser->u_name);
 269    }
 270  /* if w_wlock is set, only one user may write, else we check acls */
 271   if (display && ((fore->w_wlock == WLOCK_OFF) ?
 272       AclCheckPermWin(D_user, ACL_WRITE, fore) :
 273       (D_user != fore->w_wlockuser)))
 274     {
 275       debug2("window %d, user %s: ", fore->w_number, D_user->u_name);
 276       debug2("writelock %d (wlockuser %s)\n", fore->w_wlock,
 277              fore->w_wlockuser ? fore->w_wlockuser->u_name : "NULL");
 278       /* XXX FIXME only display !*/
 279       WBell(fore, visual_bell);
 280       *bufpp += *lenp;
 281       *lenp = 0;
 282       return;
 283     }
 284 #endif /* MULTIUSER */
 285
 286 #ifdef BUILTIN_TELNET
 287   if (fore->w_type == W_TYPE_TELNET && TelIsline(fore) && *bufpp != fore->w_telbuf)
 288     {
 289       TelProcessLine(bufpp, lenp);
 290       return;
 291     }
 292 #endif
 293
 294 #ifdef PSEUDOS
 295   if (W_UWP(fore))
 296     {
 297       /* we send the user input to our pseudowin */
 298       ibuf = fore->w_pwin->p_inbuf; ilen = &fore->w_pwin->p_inlen;
 299       f = sizeof(fore->w_pwin->p_inbuf) - *ilen;
 300     }
 301   else
 302 #endif /* PSEUDOS */
 303     {
 304       /* we send the user input to the window */
 305       ibuf = fore->w_inbuf; ilen = &fore->w_inlen;
 306       f = sizeof(fore->w_inbuf) - *ilen;
 307     }
 308
 309   if (l > f)
 310     l = f;
 311 #ifdef BUILTIN_TELNET
 312   while (l > 0)
 313 #else
 314   if (l > 0)
 315 #endif
 316     {
 317       l2 = l;
 318       bcopy(*bufpp, ibuf + *ilen, l2);
 319       if (fore->w_autolf && (trunc = DoAutolf(ibuf + *ilen, &l2, f - l2)))
 320         l -= trunc;
 321 #ifdef BUILTIN_TELNET
 322       if (fore->w_type == W_TYPE_TELNET && (trunc = DoTelnet(ibuf + *ilen, &l2, f - l2)))
 323         {
 324           l -= trunc;
 325           if (fore->w_autolf)
 326             continue;           /* need exact value */
 327         }
 328 #endif
 329       *ilen += l2;
 330       *bufpp += l;
 331       *lenp -= l;
 332       return;
 333     }
 334 }
 335
 336 static void
 337 ZombieProcess(bufpp, lenp)
 338 char **bufpp;
 339 int *lenp;
 340 {
 341   int l = *lenp;
 342   char *buf = *bufpp, b1[10], b2[10];
 343
 344   debug1("ZombieProcess: %d bytes\n", *lenp);
 345   fore = (struct win *)flayer->l_data;
 346
 347   ASSERT(fore->w_ptyfd < 0);
 348   *bufpp += *lenp;
 349   *lenp = 0;
 350   for (; l-- > 0; buf++)
 351     {
 352       if (*(unsigned char *)buf == ZombieKey_destroy)
 353         {
 354           debug1("Turning undead: %d\n", fore->w_number);
 355           KillWindow(fore);
 356           return;
 357         }
 358       if (*(unsigned char *)buf == ZombieKey_resurrect)
 359         {
 360           debug1("Resurrecting Zombie: %d\n", fore->w_number);
 361           WriteString(fore, "\r\n", 2);
 362           RemakeWindow(fore);
 363           return;
 364         }
 365     }
 366   b1[AddXChar(b1, ZombieKey_destroy)] = '\0';
 367   b2[AddXChar(b2, ZombieKey_resurrect)] = '\0';
 368   Msg(0, "Press %s to destroy or %s to resurrect window", b1, b2);
 369 }
 370
 371 static void
 372 WinRedisplayLine(y, from, to, isblank)
 373 int y, from, to, isblank;
 374 {
 375   debug3("WinRedisplayLine %d %d %d\n", y, from, to);
 376   if (y < 0)
 377     return;
 378   fore = (struct win *)flayer->l_data;
 379   if (from == 0 && y > 0 && fore->w_mlines[y - 1].image[fore->w_width] == 0)
 380     LCDisplayLineWrap(&fore->w_layer, &fore->w_mlines[y], y, from, to, isblank);
 381   else
 382     LCDisplayLine(&fore->w_layer, &fore->w_mlines[y], y, from, to, isblank);
 383 }
 384
 385 static int
 386 WinRewrite(y, x1, x2, rend, doit)
 387 int y, x1, x2, doit;
 388 struct mchar *rend;
 389 {
 390   register int cost, dx;
 391   register unsigned char *p, *i;
 392 #ifdef FONT
 393   register unsigned char *f;
 394 #endif
 395 #ifdef COLOR
 396   register unsigned char *c;
 397 # ifdef COLORS256
 398   register unsigned char *cx;
 399 # endif
 400 #endif
 401
 402   debug3("WinRewrite %d, %d-%d\n", y, x1, x2);
 403   fore = (struct win *)flayer->l_data;
 404   dx = x2 - x1 + 1;
 405   if (doit)
 406     {
 407       i = fore->w_mlines[y].image + x1;
 408       while (dx-- > 0)
 409         PUTCHAR(*i++);
 410       return 0;
 411     }
 412   p = fore->w_mlines[y].attr + x1;
 413 #ifdef FONT
 414   f = fore->w_mlines[y].font + x1;
 415 # ifdef DW_CHARS
 416   if (is_dw_font(rend->font))
 417     return EXPENSIVE;
 418 # endif
 419 # ifdef UTF8
 420   if (fore->w_encoding && fore->w_encoding != UTF8 && D_encoding == UTF8 && ContainsSpecialDeffont(fore->w_mlines + y, x1, x2, fore->w_encoding))
 421     return EXPENSIVE;
 422 # endif
 423 #endif
 424 #ifdef COLOR
 425   c = fore->w_mlines[y].color + x1;
 426 # ifdef COLORS256
 427   cx = fore->w_mlines[y].colorx + x1;
 428 # endif
 429 #endif
 430
 431   cost = dx = x2 - x1 + 1;
 432   while(dx-- > 0)
 433     {
 434       if (*p++ != rend->attr)
 435         return EXPENSIVE;
 436 #ifdef FONT
 437       if (*f++ != rend->font)
 438         return EXPENSIVE;
 439 #endif
 440 #ifdef COLOR
 441       if (*c++ != rend->color)
 442         return EXPENSIVE;
 443 # ifdef COLORS256
 444       if (*cx++ != rend->colorx)
 445         return EXPENSIVE;
 446 # endif
 447 #endif
 448     }
 449   return cost;
 450 }
 451
 452 static void
 453 WinClearLine(y, xs, xe, bce)
 454 int y, xs, xe, bce;
 455 {
 456   fore = (struct win *)flayer->l_data;
 457   debug3("WinClearLine %d %d-%d\n", y, xs, xe);
 458   LClearLine(flayer, y, xs, xe, bce, &fore->w_mlines[y]);
 459 }
 460
 461 static int
 462 WinResize(wi, he)
 463 int wi, he;
 464 {
 465   fore = (struct win *)flayer->l_data;
 466   ChangeWindowSize(fore, wi, he, fore->w_histheight);
 467   return 0;
 468 }
 469
 470 static void
 471 WinRestore()
 472 {
 473   struct canvas *cv;
 474   fore = (struct win *)flayer->l_data;
 475   debug1("WinRestore: win %p\n", fore);
 476   for (cv = flayer->l_cvlist; cv; cv = cv->c_next)
 477     {
 478       display = cv->c_display;
 479       if (cv != D_forecv)
 480         continue;
 481       /* ChangeScrollRegion(fore->w_top, fore->w_bot); */
 482       KeypadMode(fore->w_keypad);
 483       CursorkeysMode(fore->w_cursorkeys);
 484       SetFlow(fore->w_flow & FLOW_NOW);
 485       InsertMode(fore->w_insert);
 486       ReverseVideo(fore->w_revvid);
 487       CursorVisibility(fore->w_curinv ? -1 : fore->w_curvvis);
 488       MouseMode(fore->w_mouse);
 489     }
 490 }
 491
 492 /*****************************************************************/
 493
 494
 495 /*
 496  * DoStartLog constructs a path for the "want to be logfile" in buf and
 497  * attempts logfopen.
 498  *
 499  * returns 0 on success.
 500  */
 501 int
 502 DoStartLog(w, buf, bufsize)
 503 struct win *w;
 504 char *buf;
 505 int bufsize;
 506 {
 507   int n;
 508   if (!w || !buf)
 509     return -1;
 510
 511   strncpy(buf, MakeWinMsg(screenlogfile, w, '%'), bufsize - 1);
 512   buf[bufsize - 1] = 0;
 513
 514   debug2("DoStartLog: win %d, file %s\n", w->w_number, buf);
 515
 516   if (w->w_log != NULL)
 517     logfclose(w->w_log);
 518
 519   if ((w->w_log = logfopen(buf, islogfile(buf) ? NULL : secfopen(buf, "a"))) == NULL)
 520     return -2;
 521   if (!logflushev.queued)
 522     {
 523       n = log_flush ? log_flush : (logtstamp_after + 4) / 5;
 524       if (n)
 525         {
 526           SetTimeout(&logflushev, n * 1000);
 527           evenq(&logflushev);
 528         }
 529     }
 530   return 0;
 531 }
 532
 533 /*
 534  * Umask & wlock are set for the user of the display,
 535  * The display d (if specified) switches to that window.
 536  */
 537 int
 538 MakeWindow(newwin)
 539 struct NewWindow *newwin;
 540 {
 541   register struct win **pp, *p;
 542   register int n, i;
 543   int f = -1;
 544   struct NewWindow nwin;
 545   int type, startat;
 546   char *TtyName;
 547 #ifdef MULTIUSER
 548   extern struct acluser *users;
 549 #endif
 550
 551   debug1("NewWindow: StartAt %d\n", newwin->StartAt);
 552   debug1("NewWindow: aka     %s\n", newwin->aka?newwin->aka:"NULL");
 553   debug1("NewWindow: dir     %s\n", newwin->dir?newwin->dir:"NULL");
 554   debug1("NewWindow: term    %s\n", newwin->term?newwin->term:"NULL");
 555
 556   nwin_compose(&nwin_default, newwin, &nwin);
 557   debug1("NWin: aka     %s\n", nwin.aka ? nwin.aka : "NULL");
 558   debug1("NWin: wlock   %d\n", nwin.wlock);
 559   debug1("NWin: Lflag   %d\n", nwin.Lflag);
 560
 561   startat = nwin.StartAt < maxwin ? nwin.StartAt : 0;
 562   pp = wtab + startat;
 563
 564   do
 565     {
 566       if (*pp == 0)
 567         break;
 568       if (++pp == wtab + maxwin)
 569         pp = wtab;
 570     }
 571   while (pp != wtab + startat);
 572   if (*pp)
 573     {
 574       Msg(0, "No more windows.");
 575       return -1;
 576     }
 577
 578 #if defined(USRLIMIT) && defined(UTMPOK)
 579   /*
 580    * Count current number of users, if logging windows in.
 581    */
 582   if (nwin.lflag && CountUsers() >= USRLIMIT)
 583     {
 584       Msg(0, "User limit reached.  Window will not be logged in.");
 585       nwin.lflag = 0;
 586     }
 587 #endif
 588   n = pp - wtab;
 589   debug1("Makewin creating %d\n", n);
 590
 591   if ((f = OpenDevice(nwin.args, nwin.lflag, &type, &TtyName)) < 0)
 592     return -1;
 593   if (type == W_TYPE_GROUP)
 594     f = -1;
 595
 596   if ((p = (struct win *)malloc(sizeof(struct win))) == 0)
 597     {
 598       close(f);
 599       Msg(0, strnomem);
 600       return -1;
 601     }
 602   bzero((char *)p, (int)sizeof(struct win));
 603
 604 #ifdef UTMPOK
 605   if (type != W_TYPE_PTY)
 606     nwin.lflag = 0;
 607 #endif
 608
 609   p->w_type = type;
 610
 611   /* save the command line so that zombies can be resurrected */
 612   for (i = 0; nwin.args[i] && i < MAXARGS - 1; i++)
 613     p->w_cmdargs[i] = SaveStr(nwin.args[i]);
 614   p->w_cmdargs[i] = 0;
 615   if (nwin.dir)
 616     p->w_dir = SaveStr(nwin.dir);
 617   if (nwin.term)
 618     p->w_term = SaveStr(nwin.term);
 619
 620   p->w_number = n;
 621   p->w_group = 0;
 622   if (p->w_type != W_TYPE_GROUP && fore && fore->w_type == W_TYPE_GROUP)
 623     p->w_group = fore;
 624   else if (p->w_type != W_TYPE_GROUP && fore && fore->w_group)
 625     p->w_group = fore->w_group;
 626 #ifdef MULTIUSER
 627   /*
 628    * This is dangerous: without a display we use creators umask
 629    * This is intended to be usefull for detached startup.
 630    * But is still better than default bits with a NULL user.
 631    */
 632   if (NewWindowAcl(p, display ? D_user : users))
 633     {
 634       free((char *)p);
 635       close(f);
 636       Msg(0, strnomem);
 637       return -1;
 638     }
 639 #endif
 640   p->w_layer.l_next = 0;
 641   p->w_layer.l_bottom = &p->w_layer;
 642   p->w_layer.l_layfn = &WinLf;
 643   p->w_layer.l_data = (char *)p;
 644   p->w_savelayer = &p->w_layer;
 645   p->w_pdisplay = 0;
 646   p->w_lastdisp = 0;
 647
 648 #ifdef MULTIUSER
 649   if (display && !AclCheckPermWin(D_user, ACL_WRITE, p))
 650     p->w_wlockuser = D_user;
 651   p->w_wlock = nwin.wlock;
 652 #endif
 653   p->w_ptyfd = f;
 654   p->w_aflag = nwin.aflag;
 655   p->w_flow = nwin.flowflag | ((nwin.flowflag & FLOW_AUTOFLAG) ? (FLOW_AUTO|FLOW_NOW) : FLOW_AUTO);
 656   if (!nwin.aka)
 657     nwin.aka = Filename(nwin.args[0]);
 658   strncpy(p->w_akabuf, nwin.aka, sizeof(p->w_akabuf) - 1);
 659   if ((nwin.aka = rindex(p->w_akabuf, '|')) != NULL)
 660     {
 661       p->w_autoaka = 0;
 662       *nwin.aka++ = 0;
 663       p->w_title = nwin.aka;
 664       p->w_akachange = nwin.aka + strlen(nwin.aka);
 665     }
 666   else
 667     p->w_title = p->w_akachange = p->w_akabuf;
 668   if (nwin.hstatus)
 669     p->w_hstatus = SaveStr(nwin.hstatus);
 670   p->w_monitor = nwin.monitor;
 671 #ifdef MULTIUSER
 672   if (p->w_monitor == MON_ON)
 673     {
 674       /* always tell all users */
 675       for (i = 0; i < maxusercount; i++)
 676         ACLBYTE(p->w_mon_notify, i) |= ACLBIT(i);
 677     }
 678 #endif
 679   /*
 680    * defsilence by Lloyd Zusman (zusman_lloyd@jpmorgan.com)
 681    */
 682   p->w_silence = nwin.silence;
 683   p->w_silencewait = SilenceWait;
 684 #ifdef MULTIUSER
 685   if (p->w_silence == SILENCE_ON)
 686     {
 687       /* always tell all users */
 688       for (i = 0; i < maxusercount; i++)
 689         ACLBYTE(p->w_lio_notify, i) |= ACLBIT(i);
 690     }
 691 #endif
 692 #ifdef COPY_PASTE
 693   p->w_slowpaste = nwin.slow;
 694 #else
 695   nwin.histheight = 0;
 696 #endif
 697
 698   p->w_norefresh = 0;
 699   strncpy(p->w_tty, TtyName, MAXSTR - 1);
 700
 701 #if 0
 702   /* XXX Fixme display resize */
 703   if (ChangeWindowSize(p, display ? D_defwidth : 80,
 704                        display ? D_defheight : 24,
 705                        nwin.histheight))
 706     {
 707       FreeWindow(p);
 708       return -1;
 709     }
 710 #else
 711   if (ChangeWindowSize(p, display ? D_forecv->c_xe - D_forecv->c_xs + 1: 80,
 712                        display ? D_forecv->c_ye - D_forecv->c_ys + 1 : 24,
 713                        nwin.histheight))
 714     {
 715       FreeWindow(p);
 716       return -1;
 717     }
 718 #endif
 719
 720   p->w_encoding = nwin.encoding;
 721   ResetWindow(p);       /* sets w_wrap, w_c1, w_gr, w_bce */
 722
 723 #ifdef FONT
 724   if (nwin.charset)
 725     SetCharsets(p, nwin.charset);
 726 #endif
 727
 728   if (VerboseCreate && type != W_TYPE_GROUP)
 729     {
 730       struct display *d = display; /* WriteString zaps display */
 731
 732       WriteString(p, ":screen (", 9);
 733       WriteString(p, p->w_title, strlen(p->w_title));
 734       WriteString(p, "):", 2);
 735       for (f = 0; p->w_cmdargs[f]; f++)
 736         {
 737           WriteString(p, " ", 1);
 738           WriteString(p, p->w_cmdargs[f], strlen(p->w_cmdargs[f]));
 739         }
 740       WriteString(p, "\r\n", 2);
 741       display = d;
 742     }
 743
 744   p->w_deadpid = 0;
 745   p->w_pid = 0;
 746 #ifdef PSEUDOS
 747   p->w_pwin = 0;
 748 #endif
 749
 750 #ifdef BUILTIN_TELNET
 751   if (type == W_TYPE_TELNET)
 752     {
 753       if (TelConnect(p))
 754         {
 755           FreeWindow(p);
 756           return -1;
 757         }
 758     }
 759   else
 760 #endif
 761   if (type == W_TYPE_PTY)
 762     {
 763       p->w_pid = ForkWindow(p, nwin.args, TtyName);
 764       if (p->w_pid < 0)
 765         {
 766           FreeWindow(p);
 767           return -1;
 768         }
 769     }
 770
 771   /*
 772    * Place the new window at the head of the most-recently-used list.
 773    */
 774   if (display && D_fore)
 775     D_other = D_fore;
 776   *pp = p;
 777   p->w_next = windows;
 778   windows = p;
 779
 780   if (type == W_TYPE_GROUP)
 781     {
 782       SetForeWindow(p);
 783       Activate(p->w_norefresh);
 784       WindowChanged((struct win*)0, 'w');
 785       WindowChanged((struct win*)0, 'W');
 786       WindowChanged((struct win*)0, 0);
 787       return n;
 788     }
 789
 790   p->w_lflag = nwin.lflag;
 791 #ifdef UTMPOK
 792   p->w_slot = (slot_t)-1;
 793 # ifdef LOGOUTOK
 794   debug1("MakeWindow will %slog in.\n", nwin.lflag?"":"not ");
 795   if (nwin.lflag & 1)
 796 # else /* LOGOUTOK */
 797   debug1("MakeWindow will log in, LOGOUTOK undefined in config.h%s.\n",
 798          nwin.lflag?"":" (although lflag=0)");
 799 # endif /* LOGOUTOK */
 800     {
 801       p->w_slot = (slot_t)0;
 802       if (display || (p->w_lflag & 2))
 803         SetUtmp(p);
 804     }
 805 # ifdef CAREFULUTMP
 806   CarefulUtmp();        /* If all 've been zombies, we've had no slot */
 807 # endif
 808 #endif /* UTMPOK */
 809
 810   if (nwin.Lflag)
 811     {
 812       char buf[1024];
 813       DoStartLog(p, buf, sizeof(buf));
 814     }
 815
 816   p->w_readev.fd = p->w_writeev.fd = p->w_ptyfd;
 817   p->w_readev.type = EV_READ;
 818   p->w_writeev.type = EV_WRITE;
 819   p->w_readev.data = p->w_writeev.data = (char *)p;
 820   p->w_readev.handler = win_readev_fn;
 821   p->w_writeev.handler = win_writeev_fn;
 822   p->w_writeev.condpos = &p->w_inlen;
 823   evenq(&p->w_readev);
 824   evenq(&p->w_writeev);
 825 #ifdef COPY_PASTE
 826   p->w_paster.pa_slowev.type = EV_TIMEOUT;
 827   p->w_paster.pa_slowev.data = (char *)&p->w_paster;
 828   p->w_paster.pa_slowev.handler = paste_slowev_fn;
 829 #endif
 830   p->w_silenceev.type = EV_TIMEOUT;
 831   p->w_silenceev.data = (char *)p;
 832   p->w_silenceev.handler = win_silenceev_fn;
 833   if (p->w_silence > 0)
 834     {
 835       debug("New window has silence enabled.\n");
 836       SetTimeout(&p->w_silenceev, p->w_silencewait * 1000);
 837       evenq(&p->w_silenceev);
 838     }
 839
 840   SetForeWindow(p);
 841   Activate(p->w_norefresh);
 842   WindowChanged((struct win*)0, 'w');
 843   WindowChanged((struct win*)0, 'W');
 844   WindowChanged((struct win*)0, 0);
 845   return n;
 846 }
 847
 848 /*
 849  * Resurrect a window from Zombie state.
 850  * The command vector is therefore stored in the window structure.
 851  * Note: The terminaltype defaults to screenterm again, the current
 852  * working directory is lost.
 853  */
 854 int
 855 RemakeWindow(p)
 856 struct win *p;
 857 {
 858   char *TtyName;
 859   int lflag, f;
 860
 861   lflag = nwin_default.lflag;
 862   if ((f = OpenDevice(p->w_cmdargs, lflag, &p->w_type, &TtyName)) < 0)
 863     return -1;
 864
 865   strncpy(p->w_tty, *TtyName ? TtyName : p->w_title, MAXSTR - 1);
 866   p->w_ptyfd = f;
 867   p->w_readev.fd = f;
 868   p->w_writeev.fd = f;
 869   evenq(&p->w_readev);
 870   evenq(&p->w_writeev);
 871
 872   if (VerboseCreate)
 873     {
 874       struct display *d = display; /* WriteString zaps display */
 875
 876       WriteString(p, ":screen (", 9);
 877       WriteString(p, p->w_title, strlen(p->w_title));
 878       WriteString(p, "):", 2);
 879       for (f = 0; p->w_cmdargs[f]; f++)
 880         {
 881           WriteString(p, " ", 1);
 882           WriteString(p, p->w_cmdargs[f], strlen(p->w_cmdargs[f]));
 883         }
 884       WriteString(p, "\r\n", 2);
 885       display = d;
 886     }
 887
 888   p->w_deadpid = 0;
 889   p->w_pid = 0;
 890 #ifdef BUILTIN_TELNET
 891   if (p->w_type == W_TYPE_TELNET)
 892     {
 893       if (TelConnect(p))
 894         return -1;
 895     }
 896   else
 897 #endif
 898   if (p->w_type == W_TYPE_PTY)
 899     {
 900       p->w_pid = ForkWindow(p, p->w_cmdargs, TtyName);
 901       if (p->w_pid < 0)
 902         return -1;
 903     }
 904
 905 #ifdef UTMPOK
 906   if (p->w_slot == (slot_t)0 && (display || (p->w_lflag & 2)))
 907     SetUtmp(p);
 908 # ifdef CAREFULUTMP
 909   CarefulUtmp();        /* If all 've been zombies, we've had no slot */
 910 # endif
 911 #endif
 912   WindowChanged(p, 'f');
 913   return p->w_number;
 914 }
 915
 916 void
 917 CloseDevice(wp)
 918 struct win *wp;
 919 {
 920   if (wp->w_ptyfd < 0)
 921     return;
 922   if (wp->w_type == W_TYPE_PTY)
 923     {
 924       /* pty 4 SALE */
 925       (void)chmod(wp->w_tty, 0666);
 926       (void)chown(wp->w_tty, 0, 0);
 927     }
 928   close(wp->w_ptyfd);
 929   wp->w_ptyfd = -1;
 930   wp->w_tty[0] = 0;
 931   evdeq(&wp->w_readev);
 932   evdeq(&wp->w_writeev);
 933 #ifdef BUILTIN_TELNET
 934   evdeq(&wp->w_telconnev);
 935 #endif
 936   wp->w_readev.fd = wp->w_writeev.fd = -1;
 937 }
 938
 939 void
 940 FreeWindow(wp)
 941 struct win *wp;
 942 {
 943   struct display *d;
 944   int i;
 945   struct canvas *cv, *ncv;
 946   struct layer *l;
 947
 948   debug1("FreeWindow %d\n", wp ? wp->w_number: -1);
 949 #ifdef PSEUDOS
 950   if (wp->w_pwin)
 951     FreePseudowin(wp);
 952 #endif
 953 #ifdef UTMPOK
 954   RemoveUtmp(wp);
 955 #endif
 956   CloseDevice(wp);
 957
 958   if (wp == console_window)
 959     {
 960       TtyGrabConsole(-1, -1, "free");
 961       console_window = 0;
 962     }
 963   if (wp->w_log != NULL)
 964     logfclose(wp->w_log);
 965   ChangeWindowSize(wp, 0, 0, 0);
 966
 967   if (wp->w_type == W_TYPE_GROUP)
 968     {
 969       struct win *win;
 970       for (win = windows; win; win = win->w_next)
 971         if (win->w_group == wp)
 972           win->w_group = wp->w_group;
 973     }
 974
 975   if (wp->w_hstatus)
 976     free(wp->w_hstatus);
 977   for (i = 0; wp->w_cmdargs[i]; i++)
 978     free(wp->w_cmdargs[i]);
 979   if (wp->w_dir)
 980     free(wp->w_dir);
 981   if (wp->w_term)
 982     free(wp->w_term);
 983   for (d = displays; d; d = d->d_next)
 984     {
 985       if (d->d_other == wp)
 986         d->d_other = d->d_fore && d->d_fore->w_next != wp ? d->d_fore->w_next : wp->w_next;
 987       if (d->d_fore == wp)
 988         d->d_fore = NULL;
 989       for (cv = d->d_cvlist; cv; cv = cv->c_next)
 990         {
 991           for (l = cv->c_layer; l; l = l->l_next)
 992             if (l->l_layfn == &WinLf)
 993               break;
 994           if (!l)
 995             continue;
 996           if ((struct win *)l->l_data != wp)
 997             continue;
 998           if (cv->c_layer == wp->w_savelayer)
 999             wp->w_savelayer = 0;
1000           KillLayerChain(cv->c_layer);
1001         }
1002     }
1003   if (wp->w_savelayer)
1004     KillLayerChain(wp->w_savelayer);
1005   for (cv = wp->w_layer.l_cvlist; cv; cv = ncv)
1006     {
1007       ncv = cv->c_lnext;
1008       cv->c_layer = &cv->c_blank;
1009       cv->c_blank.l_cvlist = cv;
1010       cv->c_lnext = 0;
1011       cv->c_xoff = cv->c_xs;
1012       cv->c_yoff = cv->c_ys;
1013       RethinkViewportOffsets(cv);
1014     }
1015   wp->w_layer.l_cvlist = 0;
1016   if (flayer == &wp->w_layer)
1017     flayer = 0;
1018
1019 #ifdef MULTIUSER
1020   FreeWindowAcl(wp);
1021 #endif /* MULTIUSER */
1022   evdeq(&wp->w_readev);         /* just in case */
1023   evdeq(&wp->w_writeev);        /* just in case */
1024   evdeq(&wp->w_silenceev);
1025 #ifdef COPY_PASTE
1026   FreePaster(&wp->w_paster);
1027 #endif
1028   free((char *)wp);
1029 }
1030
1031 static int
1032 OpenDevice(args, lflag, typep, namep)
1033 char **args;
1034 int lflag;
1035 int *typep;
1036 char **namep;
1037 {
1038   char *arg = args[0];
1039   struct stat st;
1040   int f;
1041
1042   if (!arg)
1043     return -1;
1044   if (strcmp(arg, "//group") == 0)
1045     {
1046       *typep = W_TYPE_GROUP;
1047       *namep = "telnet";
1048       return 0;
1049     }
1050 #ifdef BUILTIN_TELNET
1051   if (strcmp(arg, "//telnet") == 0)
1052     {
1053       f = TelOpen(args + 1);
1054       lflag = 0;
1055       *typep = W_TYPE_TELNET;
1056       *namep = "telnet";
1057     }
1058   else
1059 #endif
1060   if ((stat(arg, &st)) == 0 && S_ISCHR(st.st_mode))
1061     {
1062       if (access(arg, R_OK | W_OK) == -1)
1063         {
1064           Msg(errno, "Cannot access line '%s' for R/W", arg);
1065           return -1;
1066         }
1067       debug("OpenDevice: OpenTTY\n");
1068       if ((f = OpenTTY(arg, args[1])) < 0)
1069         return -1;
1070       lflag = 0;
1071       *typep = W_TYPE_PLAIN;
1072       *namep = arg;
1073     }
1074   else
1075     {
1076       *typep = W_TYPE_PTY;
1077       f = OpenPTY(namep);
1078       if (f == -1)
1079         {
1080           Msg(0, "No more PTYs.");
1081           return -1;
1082         }
1083 #ifdef TIOCPKT
1084       {
1085         int flag = 1;
1086         if (ioctl(f, TIOCPKT, (char *)&flag))
1087           {
1088             Msg(errno, "TIOCPKT ioctl");
1089             close(f);
1090             return -1;
1091           }
1092       }
1093 #endif /* TIOCPKT */
1094     }
1095   debug1("fcntl(%d, F_SETFL, FNBLOCK)\n", f);
1096   (void) fcntl(f, F_SETFL, FNBLOCK);
1097 #ifdef linux
1098   /*
1099    * Tenebreux (zeus@ns.acadiacom.net) has Linux 1.3.70 where select
1100    * gets confused in the following condition:
1101    * Open a pty-master side, request a flush on it, then set packet
1102    * mode and call select(). Select will return a possible read, where
1103    * the one byte response to the flush can be found. Select will
1104    * thereafter return a possible read, which yields I/O error.
1105    *
1106    * If we request another flush *after* switching into packet mode,
1107    * this I/O error does not occur. We receive a single response byte
1108    * although we send two flush requests now.
1109    *
1110    * Maybe we should not flush at all.
1111    *
1112    * 10.5.96 jw.
1113    */
1114   if (*typep == W_TYPE_PTY || *typep == W_TYPE_PLAIN)
1115     tcflush(f, TCIOFLUSH);
1116 #endif
1117
1118   if (*typep != W_TYPE_PTY)
1119     return f;
1120
1121 #ifndef PTYROFS
1122 #ifdef PTYGROUP
1123   if (chown(*namep, real_uid, PTYGROUP) && !eff_uid)
1124 #else
1125   if (chown(*namep, real_uid, real_gid) && !eff_uid)
1126 #endif
1127     {
1128       Msg(errno, "chown tty");
1129       close(f);
1130       return -1;
1131     }
1132 #ifdef UTMPOK
1133   if (chmod(*namep, lflag ? TtyMode : (TtyMode & ~022)) && !eff_uid)
1134 #else
1135   if (chmod(*namep, TtyMode) && !eff_uid)
1136 #endif
1137     {
1138       Msg(errno, "chmod tty");
1139       close(f);
1140       return -1;
1141     }
1142 #endif
1143   return f;
1144 }
1145
1146 /*
1147  * Fields w_width, w_height, aflag, number (and w_tty)
1148  * are read from struct win *win. No fields written.
1149  * If pwin is nonzero, filedescriptors are distributed
1150  * between win->w_tty and open(ttyn)
1151  *
1152  */
1153 static int
1154 ForkWindow(win, args, ttyn)
1155 struct win *win;
1156 char **args, *ttyn;
1157 {
1158   int pid;
1159   char tebuf[25];
1160   char ebuf[20];
1161   char shellbuf[7 + MAXPATHLEN];
1162   char *proc;
1163 #ifndef TIOCSWINSZ
1164   char libuf[20], cobuf[20];
1165 #endif
1166   int newfd;
1167   int w = win->w_width;
1168   int h = win->w_height;
1169 #ifdef PSEUDOS
1170   int i, pat, wfdused;
1171   struct pseudowin *pwin = win->w_pwin;
1172 #endif
1173   int slave = -1;
1174
1175 #ifdef O_NOCTTY
1176   if (pty_preopen)
1177     {
1178       debug("pre-opening slave...\n");
1179       if ((slave = open(ttyn, O_RDWR|O_NOCTTY)) == -1)
1180         {
1181           Msg(errno, "ttyn");
1182           return -1;
1183         }
1184     }
1185 #endif
1186   debug("forking...\n");
1187   proc = *args;
1188   if (proc == 0)
1189     {
1190       args = ShellArgs;
1191       proc = *args;
1192     }
1193   fflush(stdout);
1194   fflush(stderr);
1195   switch (pid = fork())
1196     {
1197     case -1:
1198       Msg(errno, "fork");
1199       break;
1200     case 0:
1201       signal(SIGHUP, SIG_DFL);
1202       signal(SIGINT, SIG_DFL);
1203       signal(SIGQUIT, SIG_DFL);
1204       signal(SIGTERM, SIG_DFL);
1205 #ifdef BSDJOBS
1206       signal(SIGTTIN, SIG_DFL);
1207       signal(SIGTTOU, SIG_DFL);
1208 #endif
1209 #ifdef SIGPIPE
1210       signal(SIGPIPE, SIG_DFL);
1211 #endif
1212 #ifdef SIGXFSZ
1213       signal(SIGXFSZ, SIG_DFL);
1214 #endif
1215
1216       displays = 0;             /* beware of Panic() */
1217       if (setgid(real_gid) || setuid(real_uid))
1218         Panic(errno, "Setuid/gid");
1219       eff_uid = real_uid;
1220       eff_gid = real_gid;
1221 #ifdef PSEUDOS
1222       if (!pwin)        /* ignore directory if pseudo */
1223 #endif
1224         if (win->w_dir && *win->w_dir && chdir(win->w_dir))
1225           Panic(errno, "Cannot chdir to %s", win->w_dir);
1226
1227       if (display)
1228         {
1229           brktty(D_userfd);
1230           freetty();
1231         }
1232       else
1233         brktty(-1);
1234 #ifdef DEBUG
1235       if (dfp && dfp != stderr)
1236         fclose(dfp);
1237 #endif
1238       if (slave != -1)
1239         {
1240           close(0);
1241           dup(slave);
1242           close(slave);
1243           closeallfiles(win->w_ptyfd);
1244           slave = dup(0);
1245         }
1246       else
1247         closeallfiles(win->w_ptyfd);
1248 #ifdef DEBUG
1249       if (dfp)  /* do not produce child debug, when debug is "off" */
1250         {
1251           char buf[256];
1252
1253           sprintf(buf, "%s/screen.child", DEBUGDIR);
1254           if ((dfp = fopen(buf, "a")) == 0)
1255             dfp = stderr;
1256           else
1257             (void) chmod(buf, 0666);
1258         }
1259       debug1("=== ForkWindow: pid %d\n", (int)getpid());
1260 #endif
1261       /* Close the three /dev/null descriptors */
1262       close(0);
1263       close(1);
1264       close(2);
1265       newfd = -1;
1266       /*
1267        * distribute filedescriptors between the ttys
1268        */
1269 #ifdef PSEUDOS
1270       pat = pwin ? pwin->p_fdpat :
1271                    ((F_PFRONT<<(F_PSHIFT*2)) | (F_PFRONT<<F_PSHIFT) | F_PFRONT);
1272       debug1("Using window pattern 0x%x\n", pat);
1273       wfdused = 0;
1274       for(i = 0; i < 3; i++)
1275         {
1276           if (pat & F_PFRONT << F_PSHIFT * i)
1277             {
1278               if (newfd < 0)
1279                 {
1280 # ifdef O_NOCTTY
1281                   if (separate_sids)
1282                     newfd = open(ttyn, O_RDWR);
1283                   else
1284                     newfd = open(ttyn, O_RDWR|O_NOCTTY);
1285 # else
1286                   newfd = open(ttyn, O_RDWR);
1287 # endif
1288                   if (newfd < 0)
1289                     Panic(errno, "Cannot open %s", ttyn);
1290                 }
1291               else
1292                 dup(newfd);
1293             }
1294           else
1295             {
1296               dup(win->w_ptyfd);
1297               wfdused = 1;
1298             }
1299         }
1300       if (wfdused)
1301         {
1302             /*
1303              * the pseudo window process should not be surprised with a
1304              * nonblocking filedescriptor. Poor Backend!
1305              */
1306             debug1("Clearing NBLOCK on window-fd(%d)\n", win->w_ptyfd);
1307             if (fcntl(win->w_ptyfd, F_SETFL, 0))
1308               Msg(errno, "Warning: clear NBLOCK fcntl failed");
1309         }
1310 #else /* PSEUDOS */
1311 # ifdef O_NOCTTY
1312       if (separate_sids)
1313         newfd = open(ttyn, O_RDWR);
1314       else
1315         newfd = open(ttyn, O_RDWR|O_NOCTTY);
1316 # else
1317       newfd = open(ttyn, O_RDWR);
1318 # endif
1319       if (newfd != 0)
1320         Panic(errno, "Cannot open %s", ttyn);
1321       dup(0);
1322       dup(0);
1323 #endif /* PSEUDOS */
1324       close(win->w_ptyfd);
1325       if (slave != -1)
1326         close(slave);
1327       if (newfd >= 0)
1328         {
1329           struct mode fakemode, *modep;
1330           InitPTY(newfd);
1331           if (fgtty(newfd))
1332             Msg(errno, "fgtty");
1333           if (display)
1334             {
1335               debug("ForkWindow: using display tty mode for new child.\n");
1336               modep = &D_OldMode;
1337             }
1338           else
1339             {
1340               debug("No display - creating tty setting\n");
1341               modep = &fakemode;
1342               InitTTY(modep, 0);
1343 #ifdef DEBUG
1344               DebugTTY(modep);
1345 #endif
1346             }
1347           /* We only want echo if the users input goes to the pseudo
1348            * and the pseudo's stdout is not send to the window.
1349            */
1350 #ifdef PSEUDOS
1351           if (pwin && (!(pat & F_UWP) || (pat & F_PBACK << F_PSHIFT)))
1352             {
1353               debug1("clearing echo on pseudywin fd (pat %x)\n", pat);
1354 # if defined(POSIX) || defined(TERMIO)
1355               modep->tio.c_lflag &= ~ECHO;
1356               modep->tio.c_iflag &= ~ICRNL;
1357 # else
1358               modep->m_ttyb.sg_flags &= ~ECHO;
1359 # endif
1360             }
1361 #endif
1362           SetTTY(newfd, modep);
1363 #ifdef TIOCSWINSZ
1364           glwz.ws_col = w;
1365           glwz.ws_row = h;
1366           (void) ioctl(newfd, TIOCSWINSZ, (char *)&glwz);
1367 #endif
1368           /* Always turn off nonblocking mode */
1369           (void)fcntl(newfd, F_SETFL, 0);
1370         }
1371 #ifndef TIOCSWINSZ
1372       sprintf(libuf, "LINES=%d", h);
1373       sprintf(cobuf, "COLUMNS=%d", w);
1374       NewEnv[5] = libuf;
1375       NewEnv[6] = cobuf;
1376 #endif
1377 #ifdef MAPKEYS
1378       NewEnv[2] = MakeTermcap(display == 0 || win->w_aflag);
1379 #else
1380       if (win->w_aflag)
1381         NewEnv[2] = MakeTermcap(1);
1382       else
1383         NewEnv[2] = Termcap;
1384 #endif
1385       strcpy(shellbuf, "SHELL=");
1386       strncpy(shellbuf + 6, ShellProg + (*ShellProg == '-'), sizeof(shellbuf) - 7);
1387       shellbuf[sizeof(shellbuf) - 1] = 0;
1388       NewEnv[4] = shellbuf;
1389       debug1("ForkWindow: NewEnv[4] = '%s'\n", shellbuf);
1390       if (win->w_term && *win->w_term && strcmp(screenterm, win->w_term) &&
1391           (strlen(win->w_term) < 20))
1392         {
1393           char *s1, *s2, tl;
1394
1395           sprintf(tebuf, "TERM=%s", win->w_term);
1396           debug2("Makewindow %d with %s\n", win->w_number, tebuf);
1397           tl = strlen(win->w_term);
1398           NewEnv[1] = tebuf;
1399           if ((s1 = index(NewEnv[2], '|')))
1400             {
1401               if ((s2 = index(++s1, '|')))
1402                 {
1403                   if (strlen(NewEnv[2]) - (s2 - s1) + tl < 1024)
1404                     {
1405                       bcopy(s2, s1 + tl, strlen(s2) + 1);
1406                       bcopy(win->w_term, s1, tl);
1407                     }
1408                 }
1409             }
1410         }
1411       sprintf(ebuf, "WINDOW=%d", win->w_number);
1412       NewEnv[3] = ebuf;
1413
1414       if (*proc == '-')
1415         proc++;
1416       if (!*proc)
1417         proc = DefaultShell;
1418       debug1("calling execvpe %s\n", proc);
1419       execvpe(proc, args, NewEnv);
1420       debug1("exec error: %d\n", errno);
1421       Panic(errno, "Cannot exec '%s'", proc);
1422     default:
1423       break;
1424     }
1425   if (slave != -1)
1426     close(slave);
1427   return pid;
1428 }
1429
1430 void
1431 execvpe(prog, args, env)
1432 char *prog, **args, **env;
1433 {
1434   register char *path = NULL, *p;
1435   char buf[1024];
1436   char *shargs[MAXARGS + 1];
1437   register int i, eaccess = 0;
1438
1439   if (rindex(prog, '/'))
1440     path = "";
1441   if (!path && !(path = getenv("PATH")))
1442     path = DefaultPath;
1443   do
1444     {
1445       for (p = buf; *path && *path != ':'; path++)
1446         if (p - buf < (int)sizeof(buf) - 2)
1447           *p++ = *path;
1448       if (p > buf)
1449         *p++ = '/';
1450       if (p - buf + strlen(prog) >= sizeof(buf) - 1)
1451         continue;
1452       strcpy(p, prog);
1453       execve(buf, args, env);
1454       switch (errno)
1455         {
1456         case ENOEXEC:
1457           shargs[0] = DefaultShell;
1458           shargs[1] = buf;
1459           for (i = 1; (shargs[i + 1] = args[i]) != NULL; ++i)
1460             ;
1461           execve(DefaultShell, shargs, env);
1462           return;
1463         case EACCES:
1464           eaccess = 1;
1465           break;
1466         case ENOMEM:
1467         case E2BIG:
1468         case ETXTBSY:
1469           return;
1470         }
1471     } while (*path++);
1472   if (eaccess)
1473     errno = EACCES;
1474 }
1475
1476 #ifdef PSEUDOS
1477
1478 int
1479 winexec(av)
1480 char **av;
1481 {
1482   char **pp;
1483   char *p, *s, *t;
1484   int i, r = 0, l = 0;
1485   struct win *w;
1486   extern struct display *display;
1487   extern struct win *windows;
1488   struct pseudowin *pwin;
1489   int type;
1490
1491   if ((w = display ? fore : windows) == NULL)
1492     return -1;
1493   if (!*av || w->w_pwin)
1494     {
1495       Msg(0, "Filter running: %s", w->w_pwin ? w->w_pwin->p_cmd : "(none)");
1496       return -1;
1497     }
1498   if (w->w_ptyfd < 0)
1499     {
1500       Msg(0, "You feel dead inside.");
1501       return -1;
1502     }
1503   if (!(pwin = (struct pseudowin *)malloc(sizeof(struct pseudowin))))
1504     {
1505       Msg(0, strnomem);
1506       return -1;
1507     }
1508   bzero((char *)pwin, (int)sizeof(*pwin));
1509
1510   /* allow ^a:!!./ttytest as a short form for ^a:exec !.. ./ttytest */
1511   for (s = *av; *s == ' '; s++)
1512     ;
1513   for (p = s; *p == ':' || *p == '.' || *p == '!'; p++)
1514     ;
1515   if (*p != '|')
1516     while (*p && p > s && p[-1] == '.')
1517       p--;
1518   if (*p == '|')
1519     {
1520       l = F_UWP;
1521       p++;
1522     }
1523   if (*p)
1524     av[0] = p;
1525   else
1526     av++;
1527
1528   t = pwin->p_cmd;
1529   for (i = 0; i < 3; i++)
1530     {
1531       *t = (s < p) ? *s++ : '.';
1532       switch (*t++)
1533         {
1534         case '.':
1535         case '|':
1536           l |= F_PFRONT << (i * F_PSHIFT);
1537           break;
1538         case '!':
1539           l |= F_PBACK << (i * F_PSHIFT);
1540           break;
1541         case ':':
1542           l |= F_PBOTH << (i * F_PSHIFT);
1543           break;
1544         }
1545     }
1546
1547   if (l & F_UWP)
1548     {
1549       *t++ = '|';
1550       if ((l & F_PMASK) == F_PFRONT)
1551         {
1552           *pwin->p_cmd = '!';
1553           l ^= F_PFRONT | F_PBACK;
1554         }
1555     }
1556   if (!(l & F_PBACK))
1557     l |= F_UWP;
1558   *t++ = ' ';
1559   pwin->p_fdpat = l;
1560   debug1("winexec: '%#x'\n", pwin->p_fdpat);
1561
1562   l = MAXSTR - 4;
1563   for (pp = av; *pp; pp++)
1564     {
1565       p = *pp;
1566       while (*p && l-- > 0)
1567         *t++ = *p++;
1568       if (l <= 0)
1569         break;
1570       *t++ = ' ';
1571     }
1572   *--t = '\0';
1573   debug1("%s\n", pwin->p_cmd);
1574
1575   if ((pwin->p_ptyfd = OpenDevice(av, 0, &type, &t)) < 0)
1576     {
1577       free((char *)pwin);
1578       return -1;
1579     }
1580   strncpy(pwin->p_tty, t, MAXSTR - 1);
1581   w->w_pwin = pwin;
1582   if (type != W_TYPE_PTY)
1583     {
1584       FreePseudowin(w);
1585       Msg(0, "Cannot only use commands as pseudo win.");
1586       return -1;
1587     }
1588   if (!(pwin->p_fdpat & F_PFRONT))
1589     evdeq(&w->w_readev);
1590 #ifdef TIOCPKT
1591   {
1592     int flag = 0;
1593
1594     if (ioctl(pwin->p_ptyfd, TIOCPKT, (char *)&flag))
1595       {
1596         Msg(errno, "TIOCPKT pwin ioctl");
1597         FreePseudowin(w);
1598         return -1;
1599       }
1600     if (w->w_type == W_TYPE_PTY && !(pwin->p_fdpat & F_PFRONT))
1601       {
1602         if (ioctl(w->w_ptyfd, TIOCPKT, (char *)&flag))
1603           {
1604             Msg(errno, "TIOCPKT win ioctl");
1605             FreePseudowin(w);
1606             return -1;
1607           }
1608       }
1609   }
1610 #endif /* TIOCPKT */
1611
1612   pwin->p_readev.fd = pwin->p_writeev.fd = pwin->p_ptyfd;
1613   pwin->p_readev.type = EV_READ;
1614   pwin->p_writeev.type = EV_WRITE;
1615   pwin->p_readev.data = pwin->p_writeev.data = (char *)w;
1616   pwin->p_readev.handler = pseu_readev_fn;
1617   pwin->p_writeev.handler = pseu_writeev_fn;
1618   pwin->p_writeev.condpos = &pwin->p_inlen;
1619   if (pwin->p_fdpat & (F_PFRONT << F_PSHIFT * 2 | F_PFRONT << F_PSHIFT))
1620     evenq(&pwin->p_readev);
1621   evenq(&pwin->p_writeev);
1622   r = pwin->p_pid = ForkWindow(w, av, t);
1623   if (r < 0)
1624     FreePseudowin(w);
1625   return r;
1626 }
1627
1628 void
1629 FreePseudowin(w)
1630 struct win *w;
1631 {
1632   struct pseudowin *pwin = w->w_pwin;
1633
1634   ASSERT(pwin);
1635   if (fcntl(w->w_ptyfd, F_SETFL, FNBLOCK))
1636     Msg(errno, "Warning: FreePseudowin: NBLOCK fcntl failed");
1637 #ifdef TIOCPKT
1638   if (w->w_type == W_TYPE_PTY && !(pwin->p_fdpat & F_PFRONT))
1639     {
1640       int flag = 1;
1641       if (ioctl(w->w_ptyfd, TIOCPKT, (char *)&flag))
1642         Msg(errno, "Warning: FreePseudowin: TIOCPKT win ioctl");
1643     }
1644 #endif
1645   /* should be able to use CloseDevice() here */
1646   (void)chmod(pwin->p_tty, 0666);
1647   (void)chown(pwin->p_tty, 0, 0);
1648   if (pwin->p_ptyfd >= 0)
1649     close(pwin->p_ptyfd);
1650   evdeq(&pwin->p_readev);
1651   evdeq(&pwin->p_writeev);
1652   if (w->w_readev.condneg == &pwin->p_inlen)
1653     w->w_readev.condpos = w->w_readev.condneg = 0;
1654   evenq(&w->w_readev);
1655   free((char *)pwin);
1656   w->w_pwin = NULL;
1657 }
1658
1659 #endif /* PSEUDOS */
1660
1661
1662 #ifdef MULTIUSER
1663 /*
1664  * returns 0, if the lock really has been released
1665  */
1666 int
1667 ReleaseAutoWritelock(dis, w)
1668 struct display *dis;
1669 struct win *w;
1670 {
1671   debug2("ReleaseAutoWritelock: user %s, window %d\n",
1672          dis->d_user->u_name, w->w_number);
1673
1674   /* release auto writelock when user has no other display here */
1675   if (w->w_wlock == WLOCK_AUTO && w->w_wlockuser == dis->d_user)
1676     {
1677       struct display *d;
1678
1679       for (d = displays; d; d = d->d_next)
1680         if (( d != dis) && (d->d_fore == w) && (d->d_user == dis->d_user))
1681           break;
1682       debug3("%s %s autolock on win %d\n",
1683              dis->d_user->u_name, d ? "keeps" : "releases", w->w_number);
1684       if (!d)
1685         {
1686           w->w_wlockuser = NULL;
1687           return 0;
1688         }
1689     }
1690   return 1;
1691 }
1692
1693 /*
1694  * returns 0, if the lock really could be obtained
1695  */
1696 int
1697 ObtainAutoWritelock(d, w)
1698 struct display *d;
1699 struct win *w;
1700 {
1701   if ((w->w_wlock == WLOCK_AUTO) &&
1702        !AclCheckPermWin(d->d_user, ACL_WRITE, w) &&
1703        !w->w_wlockuser)
1704     {
1705       debug2("%s obtained auto writelock for exported window %d\n",
1706              d->d_user->u_name, w->w_number);
1707       w->w_wlockuser = d->d_user;
1708       return 0;
1709     }
1710   return 1;
1711 }
1712
1713 #endif /* MULTIUSER */
1714
1715
1716
1717 /********************************************************************/
1718
1719 #ifdef COPY_PASTE
1720 static void
1721 paste_slowev_fn(ev, data)
1722 struct event *ev;
1723 char *data;
1724 {
1725   struct paster *pa = (struct paster *)data;
1726   struct win *p;
1727
1728   int l = 1;
1729   flayer = pa->pa_pastelayer;
1730   if (!flayer)
1731     pa->pa_pastelen = 0;
1732   if (!pa->pa_pastelen)
1733     return;
1734   p = Layer2Window(flayer);
1735   DoProcess(p, &pa->pa_pasteptr, &l, pa);
1736   pa->pa_pastelen -= 1 - l;
1737   if (pa->pa_pastelen > 0)
1738     {
1739       SetTimeout(&pa->pa_slowev, p->w_slowpaste);
1740       evenq(&pa->pa_slowev);
1741     }
1742 }
1743 #endif
1744
1745
1746 static int
1747 muchpending(p, ev)
1748 struct win *p;
1749 struct event *ev;
1750 {
1751   struct canvas *cv;
1752   for (cv = p->w_layer.l_cvlist; cv; cv = cv->c_lnext)
1753     {
1754       display = cv->c_display;
1755       if (D_status == STATUS_ON_WIN && !D_status_bell)
1756         {
1757           /* wait 'til status is gone */
1758           debug("BLOCKING because of status\n");
1759           ev->condpos = &const_one;
1760           ev->condneg = &D_status;
1761           return 1;
1762         }
1763       debug2("muchpending %s %d: ", D_usertty, D_blocked);
1764       debug3("%d %d %d\n", D_obufp - D_obuf, D_obufmax, D_blocked_fuzz);
1765       if (D_blocked)
1766         continue;
1767       if (D_obufp - D_obuf > D_obufmax + D_blocked_fuzz)
1768         {
1769           if (D_nonblock == 0)
1770             {
1771               debug1("obuf is full, stopping output to display %s\n", D_usertty);
1772               D_blocked = 1;
1773               continue;
1774             }
1775           debug("BLOCKING because of full obuf\n");
1776           ev->condpos = &D_obuffree;
1777           ev->condneg = &D_obuflenmax;
1778           if (D_nonblock > 0 && !D_blockedev.queued)
1779             {
1780               debug1("created timeout of %g secs\n", D_nonblock/1000.);
1781               SetTimeout(&D_blockedev, D_nonblock);
1782               evenq(&D_blockedev);
1783             }
1784           return 1;
1785         }
1786     }
1787   return 0;
1788 }
1789
1790 static void
1791 win_readev_fn(ev, data)
1792 struct event *ev;
1793 char *data;
1794 {
1795   struct win *p = (struct win *)data;
1796   char buf[IOSIZE], *bp;
1797   int size, len;
1798 #ifdef PSEUDOS
1799   int wtop;
1800 #endif
1801
1802   bp = buf;
1803   size = IOSIZE;
1804
1805 #ifdef PSEUDOS
1806   wtop = p->w_pwin && W_WTOP(p);
1807   if (wtop)
1808     {
1809       ASSERT(sizeof(p->w_pwin->p_inbuf) == IOSIZE);
1810       size = IOSIZE - p->w_pwin->p_inlen;
1811       if (size <= 0)
1812         {
1813           ev->condpos = &const_IOSIZE;
1814           ev->condneg = &p->w_pwin->p_inlen;
1815           return;
1816         }
1817     }
1818 #endif
1819   if (p->w_layer.l_cvlist && muchpending(p, ev))
1820     return;
1821 #ifdef ZMODEM
1822   if (!p->w_zdisplay)
1823 #endif
1824     if (p->w_blocked)
1825       {
1826         ev->condpos = &const_one;
1827         ev->condneg = &p->w_blocked;
1828         return;
1829       }
1830   if (ev->condpos)
1831     ev->condpos = ev->condneg = 0;
1832
1833   if ((len = p->w_outlen))
1834     {
1835       p->w_outlen = 0;
1836       WriteString(p, p->w_outbuf, len);
1837       return;
1838     }
1839
1840   debug1("going to read from window fd %d\n", ev->fd);
1841   if ((len = read(ev->fd, buf, size)) < 0)
1842     {
1843       if (errno == EINTR || errno == EAGAIN)
1844         return;
1845 #if defined(EWOULDBLOCK) && (EWOULDBLOCK != EAGAIN)
1846       if (errno == EWOULDBLOCK)
1847         return;
1848 #endif
1849       debug2("Window %d: read error (errno %d) - killing window\n", p->w_number, errno);
1850       WindowDied(p, 0, 0);
1851       return;
1852     }
1853   if (len == 0)
1854     {
1855       debug1("Window %d: EOF - killing window\n", p->w_number);
1856       WindowDied(p, 0, 0);
1857       return;
1858     }
1859   debug1(" -> %d bytes\n", len);
1860 #ifdef TIOCPKT
1861   if (p->w_type == W_TYPE_PTY)
1862     {
1863       if (buf[0])
1864         {
1865           debug1("PAKET %x\n", buf[0]);
1866           if (buf[0] & TIOCPKT_NOSTOP)
1867             WNewAutoFlow(p, 0);
1868           if (buf[0] & TIOCPKT_DOSTOP)
1869             WNewAutoFlow(p, 1);
1870         }
1871       bp++;
1872       len--;
1873     }
1874 #endif
1875 #ifdef BUILTIN_TELNET
1876   if (p->w_type == W_TYPE_TELNET)
1877     len = TelIn(p, bp, len, buf + sizeof(buf) - (bp + len));
1878 #endif
1879   if (len == 0)
1880     return;
1881 #ifdef ZMODEM
1882   if (zmodem_mode && zmodem_parse(p, bp, len))
1883     return;
1884 #endif
1885 #ifdef PSEUDOS
1886   if (wtop)
1887     {
1888       debug("sending input to pwin\n");
1889       bcopy(bp, p->w_pwin->p_inbuf + p->w_pwin->p_inlen, len);
1890       p->w_pwin->p_inlen += len;
1891     }
1892 #endif
1893   WriteString(p, bp, len);
1894   return;
1895 }
1896
1897
1898 static void
1899 win_writeev_fn(ev, data)
1900 struct event *ev;
1901 char *data;
1902 {
1903   struct win *p = (struct win *)data;
1904   int len;
1905   if (p->w_inlen)
1906     {
1907       debug2("writing %d bytes to win %d\n", p->w_inlen, p->w_number);
1908       if ((len = write(ev->fd, p->w_inbuf, p->w_inlen)) <= 0)
1909         len = p->w_inlen;       /* dead window */
1910       if ((p->w_inlen -= len))
1911         bcopy(p->w_inbuf + len, p->w_inbuf, p->w_inlen);
1912     }
1913 #ifdef COPY_PASTE
1914   if (p->w_paster.pa_pastelen && !p->w_slowpaste)
1915     {
1916       struct paster *pa = &p->w_paster;
1917       flayer = pa->pa_pastelayer;
1918       if (flayer)
1919         DoProcess(p, &pa->pa_pasteptr, &pa->pa_pastelen, pa);
1920     }
1921 #endif
1922   return;
1923 }
1924
1925
1926
1927 #ifdef PSEUDOS
1928
1929 static void
1930 pseu_readev_fn(ev, data)
1931 struct event *ev;
1932 char *data;
1933 {
1934   struct win *p = (struct win *)data;
1935   char buf[IOSIZE];
1936   int size, ptow, len;
1937
1938   size = IOSIZE;
1939
1940   ptow = W_PTOW(p);
1941   if (ptow)
1942     {
1943       ASSERT(sizeof(p->w_inbuf) == IOSIZE);
1944       size = IOSIZE - p->w_inlen;
1945       if (size <= 0)
1946         {
1947           ev->condpos = &const_IOSIZE;
1948           ev->condneg = &p->w_inlen;
1949           return;
1950         }
1951     }
1952   if (p->w_layer.l_cvlist && muchpending(p, ev))
1953     return;
1954   if (p->w_blocked)
1955     {
1956       ev->condpos = &const_one;
1957       ev->condneg = &p->w_blocked;
1958       return;
1959     }
1960   if (ev->condpos)
1961     ev->condpos = ev->condneg = 0;
1962
1963   if ((len = p->w_outlen))
1964     {
1965       p->w_outlen = 0;
1966       WriteString(p, p->w_outbuf, len);
1967       return;
1968     }
1969
1970   if ((len = read(ev->fd, buf, size)) <= 0)
1971     {
1972       if (errno == EINTR || errno == EAGAIN)
1973         return;
1974 #if defined(EWOULDBLOCK) && (EWOULDBLOCK != EAGAIN)
1975       if (errno == EWOULDBLOCK)
1976         return;
1977 #endif
1978       debug2("Window %d: pseudowin read error (errno %d) -- removing pseudowin\n", p->w_number, len ? errno : 0);
1979       FreePseudowin(p);
1980       return;
1981     }
1982   /* no packet mode on pseudos! */
1983   if (ptow)
1984     {
1985       bcopy(buf, p->w_inbuf + p->w_inlen, len);
1986       p->w_inlen += len;
1987     }
1988   WriteString(p, buf, len);
1989   return;
1990 }
1991
1992 static void
1993 pseu_writeev_fn(ev, data)
1994 struct event *ev;
1995 char *data;
1996 {
1997   struct win *p = (struct win *)data;
1998   struct pseudowin *pw = p->w_pwin;
1999   int len;
2000
2001   ASSERT(pw);
2002   if (pw->p_inlen == 0)
2003     return;
2004   if ((len = write(ev->fd, pw->p_inbuf, pw->p_inlen)) <= 0)
2005     len = pw->p_inlen;          /* dead pseudo */
2006   if ((p->w_pwin->p_inlen -= len))
2007     bcopy(p->w_pwin->p_inbuf + len, p->w_pwin->p_inbuf, p->w_pwin->p_inlen);
2008 }
2009
2010
2011 #endif /* PSEUDOS */
2012
2013 static void
2014 win_silenceev_fn(ev, data)
2015 struct event *ev;
2016 char *data;
2017 {
2018   struct win *p = (struct win *)data;
2019   struct canvas *cv;
2020   debug1("FOUND silence win %d\n", p->w_number);
2021   for (display = displays; display; display = display->d_next)
2022     {
2023       for (cv = D_cvlist; cv; cv = cv->c_next)
2024         if (cv->c_layer->l_bottom == &p->w_layer)
2025           break;
2026       if (cv)
2027         continue;       /* user already sees window */
2028 #ifdef MULTIUSER
2029       if (!(ACLBYTE(p->w_lio_notify, D_user->u_id) & ACLBIT(D_user->u_id)))
2030         continue;
2031 #endif
2032       Msg(0, "Window %d: silence for %d seconds", p->w_number, p->w_silencewait);
2033     }
2034 }
2035
2036 #ifdef ZMODEM
2037
2038 static int
2039 zmodem_parse(p, bp, len)
2040 struct win *p;
2041 char *bp;
2042 int len;
2043 {
2044   int i;
2045   char *b2 = bp;
2046   for (i = 0; i < len; i++, b2++)
2047     {
2048       if (p->w_zauto == 0)
2049         {
2050           for (; i < len; i++, b2++)
2051             if (*b2 == 030)
2052               break;
2053           if (i == len)
2054             break;
2055           if (i > 1 && b2[-1] == '*' && b2[-2] == '*')
2056             p->w_zauto = 3;
2057           continue;
2058         }
2059       if (p->w_zauto > 5 || *b2 == "**\030B00"[p->w_zauto] || (p->w_zauto == 5 && *b2 == '1') || (p->w_zauto == 5 && p->w_zdisplay && *b2 == '8'))
2060         {
2061           if (++p->w_zauto < 6)
2062             continue;
2063           if (p->w_zauto == 6)
2064             p->w_zauto = 0;
2065           if (!p->w_zdisplay)
2066             {
2067               if (i > 6)
2068                 WriteString(p, bp, i + 1 - 6);
2069               WriteString(p, "\r\n", 2);
2070               zmodem_found(p, *b2 == '1', b2 + 1, len - i - 1);
2071               return 1;
2072             }
2073           else if (p->w_zauto == 7 || *b2 == '8')
2074             {
2075               int se = p->w_zdisplay->d_blocked == 2 ? 'O' : '\212';
2076               for (; i < len; i++, b2++)
2077                 if (*b2 == se)
2078                   break;
2079               if (i < len)
2080                 {
2081                   zmodem_abort(p, 0);
2082                   D_blocked = 0;
2083                   D_readev.condpos = D_readev.condneg = 0;
2084                   while (len-- > 0)
2085                     AddChar(*bp++);
2086                   Flush();
2087                   Activate(D_fore ? D_fore->w_norefresh : 0);
2088                   return 1;
2089                 }
2090               p->w_zauto = 6;
2091             }
2092         }
2093       else
2094         p->w_zauto = *b2 == '*' ? (p->w_zauto == 2 ? 2 : 1) : 0;
2095     }
2096   if (p->w_zauto == 0 && bp[len - 1] == '*')
2097     p->w_zauto = len > 1 && bp[len - 2] == '*' ? 2 : 1;
2098   if (p->w_zdisplay)
2099     {
2100       display = p->w_zdisplay;
2101       while (len-- > 0)
2102         AddChar(*bp++);
2103       return 1;
2104     }
2105   return 0;
2106 }
2107
2108 static void
2109 zmodem_fin(buf, len, data)
2110 char *buf;
2111 int len;
2112 char *data;
2113 {
2114   char *s;
2115   int n;
2116
2117   if (len)
2118     RcLine(buf, strlen(buf) + 1);
2119   else
2120     {
2121       s = "\030\030\030\030\030\030\030\030\030\030";
2122       n = strlen(s);
2123       LayProcess(&s, &n);
2124     }
2125 }
2126
2127 static void
2128 zmodem_found(p, send, bp, len)
2129 struct win *p;
2130 int send;
2131 char *bp;
2132 int len;
2133 {
2134   char *s;
2135   int i, n;
2136   extern int zmodem_mode;
2137
2138   /* check for abort sequence */
2139   n = 0;
2140   for (i = 0; i < len ; i++)
2141     if (bp[i] != 030)
2142       n = 0;
2143     else if (++n > 4)
2144       return;
2145   if (zmodem_mode == 3 || (zmodem_mode == 1 && p->w_type != W_TYPE_PLAIN))
2146     {
2147       struct display *d, *olddisplay;
2148
2149       olddisplay = display;
2150       d = p->w_lastdisp;
2151       if (!d || d->d_fore != p)
2152         for (d = displays; d; d = d->d_next)
2153           if (d->d_fore == p)
2154             break;
2155       if (!d && p->w_layer.l_cvlist)
2156         d = p->w_layer.l_cvlist->c_display;
2157       if (!d)
2158         d = displays;
2159       if (!d)
2160         return;
2161       display = d;
2162       RemoveStatus();
2163       p->w_zdisplay = display;
2164       D_blocked = 2 + send;
2165       flayer = &p->w_layer;
2166       ZmodemPage();
2167       display = d;
2168       evdeq(&D_blockedev);
2169       D_readev.condpos = &const_IOSIZE;
2170       D_readev.condneg = &p->w_inlen;
2171       ClearAll();
2172       GotoPos(0, 0);
2173       SetRendition(&mchar_blank);
2174       AddStr("Zmodem active\r\n\r\n");
2175       AddStr(send ? "**\030B01" : "**\030B00");
2176       while (len-- > 0)
2177         AddChar(*bp++);
2178       display = olddisplay;
2179       return;
2180     }
2181   flayer = &p->w_layer;
2182   Input(":", 100, INP_COOKED, zmodem_fin, NULL, 0);
2183   s = send ? zmodem_sendcmd : zmodem_recvcmd;
2184   n = strlen(s);
2185   LayProcess(&s, &n);
2186 }
2187
2188 void
2189 zmodem_abort(p, d)
2190 struct win *p;
2191 struct display *d;
2192 {
2193   struct display *olddisplay = display;
2194   struct layer *oldflayer = flayer;
2195   if (p)
2196     {
2197       if (p->w_savelayer && p->w_savelayer->l_next)
2198         {
2199           if (oldflayer == p->w_savelayer)
2200             oldflayer = flayer->l_next;
2201           flayer = p->w_savelayer;
2202           ExitOverlayPage();
2203         }
2204       p->w_zdisplay = 0;
2205       p->w_zauto = 0;
2206       LRefreshAll(&p->w_layer, 0);
2207     }
2208   if (d)
2209     {
2210       display = d;
2211       D_blocked = 0;
2212       D_readev.condpos = D_readev.condneg = 0;
2213       Activate(D_fore ? D_fore->w_norefresh : 0);
2214     }
2215   display = olddisplay;
2216   flayer = oldflayer;
2217 }
2218
2219 #endif