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