?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix another instance of unknown format strings.
[screen-lua.git] / src / process.c
blob8fd2fa760f4a9202131fe4d4a431457a31ce58a2
1 /* Copyright (c) 2008, 2009
2 * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
3 * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
4 * Micah Cowan (micah@cowan.name)
5 * Sadrul Habib Chowdhury (sadrul@users.sourceforge.net)
6 * Copyright (c) 1993-2002, 2003, 2005, 2006, 2007
7 * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
8 * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
9 * Copyright (c) 1987 Oliver Laumann
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 3, or (at your option)
14 * any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program (see the file COPYING); if not, see
23 * http://www.gnu.org/licenses/, or contact Free Software Foundation, Inc.,
24 * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
25 *
26 ****************************************************************
27 */
28
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 #include <signal.h>
32 #include <fcntl.h>
33 #if !defined(sun) && !defined(B43) && !defined(ISC) && !defined(pyr) && !defined(_CX_UX)
34 # include <time.h>
35 #endif
36 #include <sys/time.h>
37 #ifndef sun
38 #include <sys/ioctl.h>
39 #endif
40
41
42 #include "config.h"
43
44 /* for solaris 2.1, Unixware (SVR4.2) and possibly others: */
45 #ifdef HAVE_STROPTS_H
46 # include <sys/stropts.h>
47 #endif
48
49 #include "screen.h"
50 #include "extern.h"
51 #include "logfile.h"
52
53 extern struct comm comms[];
54 extern char *rc_name;
55 extern char *RcFileName, *home;
56 extern char *BellString, *ActivityString, *ShellProg, *ShellArgs[];
57 extern char *hstatusstring, *captionstring, *timestring;
58 extern char *wliststr, *wlisttit;
59 extern int captionalways;
60 extern char *hardcopydir, *screenlogfile, *logtstamp_string;
61 extern int log_flush, logtstamp_on, logtstamp_after;
62 extern char *VisualBellString;
63 extern int VBellWait, MsgWait, MsgMinWait, SilenceWait;
64 extern char SockPath[], *SockName;
65 extern int TtyMode, auto_detach, use_altscreen;
66 extern int iflag, maxwin;
67 extern int focusminwidth, focusminheight;
68 extern int use_hardstatus, visual_bell;
69 #ifdef COLOR
70 extern int attr2color[][4];
71 extern int nattr2color;
72 #endif
73 extern int hardstatusemu;
74 extern char *printcmd;
75 extern int default_startup;
76 extern int defobuflimit;
77 extern int defnonblock;
78 extern int ZombieKey_destroy;
79 extern int ZombieKey_resurrect;
80 extern int ZombieKey_onerror;
81 #ifdef AUTO_NUKE
82 extern int defautonuke;
83 #endif
84 extern int separate_sids;
85 extern struct NewWindow nwin_default, nwin_undef;
86 #ifdef COPY_PASTE
87 extern int join_with_cr;
88 extern int compacthist;
89 extern int search_ic;
90 # ifdef FONT
91 extern int pastefont;
92 # endif
93 extern unsigned char mark_key_tab[];
94 extern char *BufferFile;
95 #endif
96 #ifdef POW_DETACH
97 extern char *BufferFile, *PowDetachString;
98 #endif
99 #ifdef MULTIUSER
100 extern struct acluser *EffectiveAclUser; /* acl.c */
101 #endif
102 extern struct term term[]; /* terminal capabilities */
103 #ifdef MAPKEYS
104 extern char *kmapdef[];
105 extern char *kmapadef[];
106 extern char *kmapmdef[];
107 #endif
108 extern struct mchar mchar_so, mchar_null;
109 extern int renditions[];
110 extern int VerboseCreate;
111 #ifdef UTF8
112 extern char *screenencodings;
113 #endif
114 #ifdef DW_CHARS
115 extern int cjkwidth;
116 #endif
117
118 static int CheckArgNum __P((int, char **));
119 static void ClearAction __P((struct action *));
120 static void SaveAction __P((struct action *, int, char **, int *));
121 static int NextWindow __P((void));
122 static int PreviousWindow __P((void));
123 static int MoreWindows __P((void));
124 static void LogToggle __P((int));
125 static void ShowInfo __P((void));
126 static void ShowDInfo __P((void));
127 static struct win *WindowByName __P((char *));
128 static int WindowByNumber __P((char *));
129 static int ParseOnOff __P((struct action *, int *));
130 static int ParseWinNum __P((struct action *, int *));
131 static int ParseBase __P((struct action *, char *, int *, int, char *));
132 static int ParseNum1000 __P((struct action *, int *));
133 static char **SaveArgs __P((char **));
134 static int IsNum __P((char *, int));
135 static void Colonfin __P((char *, int, char *));
136 static void InputSelect __P((void));
137 static void InputSetenv __P((char *));
138 static void InputAKA __P((void));
139 #ifdef MULTIUSER
140 static int InputSu __P((struct win *, struct acluser **, char *));
141 static void su_fin __P((char *, int, char *));
142 #endif
143 static void AKAfin __P((char *, int, char *));
144 #ifdef COPY_PASTE
145 static void copy_reg_fn __P((char *, int, char *));
146 static void ins_reg_fn __P((char *, int, char *));
147 #endif
148 static void process_fn __P((char *, int, char *));
149 #ifdef PASSWORD
150 static void pass1 __P((char *, int, char *));
151 static void pass2 __P((char *, int, char *));
152 #endif
153 #ifdef POW_DETACH
154 static void pow_detach_fn __P((char *, int, char *));
155 #endif
156 static void digraph_fn __P((char *, int, char *));
157 static int digraph_find __P((const char *buf));
158 static void confirm_fn __P((char *, int, char *));
159 static int IsOnDisplay __P((struct win *));
160 static void ResizeRegions __P((char *, int));
161 static void ResizeFin __P((char *, int, char *));
162 static struct action *FindKtab __P((char *, int));
163 static void SelectFin __P((char *, int, char *));
164 static void SelectLayoutFin __P((char *, int, char *));
165
166
167 extern struct layer *flayer;
168 extern struct display *display, *displays;
169 extern struct win *fore, *console_window, *windows;
170 extern struct acluser *users;
171 extern struct layout *layouts, *layout_attach, layout_last_marker;
172 extern struct layout *laytab[];
173
174 extern char screenterm[], HostName[], version[];
175 extern struct NewWindow nwin_undef, nwin_default;
176 extern struct LayFuncs WinLf, MarkLf;
177
178 extern int Z0width, Z1width;
179 extern int real_uid, real_gid;
180
181 #ifdef NETHACK
182 extern int nethackflag;
183 #endif
184
185
186 struct win *wtab[MAXWIN]; /* window table, should be dynamic */
187
188 #ifdef MULTIUSER
189 extern char *multi;
190 extern int maxusercount;
191 #endif
192 char NullStr[] = "";
193
194 struct plop plop_tab[MAX_PLOP_DEFS];
195
196 #ifndef PTYMODE
197 # define PTYMODE 0622
198 #endif
199
200 int TtyMode = PTYMODE;
201 int hardcopy_append = 0;
202 int all_norefresh = 0;
203 #ifdef ZMODEM
204 int zmodem_mode = 0;
205 char *zmodem_sendcmd;
206 char *zmodem_recvcmd;
207 static char *zmodes[4] = {"off", "auto", "catch", "pass"};
208 #endif
209
210 int idletimo;
211 struct action idleaction;
212 #ifdef BLANKER_PRG
213 char **blankerprg;
214 #endif
215
216 struct action ktab[256 + KMAP_KEYS]; /* command key translation table */
217 struct kclass {
218 struct kclass *next;
219 char *name;
220 struct action ktab[256 + KMAP_KEYS];
221 };
222 struct kclass *kclasses;
223
224 #ifdef MAPKEYS
225 struct action umtab[KMAP_KEYS+KMAP_AKEYS];
226 struct action dmtab[KMAP_KEYS+KMAP_AKEYS];
227 struct action mmtab[KMAP_KEYS+KMAP_AKEYS];
228 struct kmap_ext *kmap_exts;
229 int kmap_extn;
230 static int maptimeout = 300;
231 #endif
232
233 #ifndef MAX_DIGRAPH
234 #define MAX_DIGRAPH 512
235 #endif
236
237 struct digraph
238 {
239 unsigned char d[2];
240 int value;
241 };
242
243 /* digraph table taken from old vim and rfc1345 */
244 static struct digraph digraphs[MAX_DIGRAPH + 1] = {
245 {' ', ' ', 160}, /*   */
246 {'N', 'S', 160}, /*   */
247 {'~', '!', 161}, /* ¡ */
248 {'!', '!', 161}, /* ¡ */
249 {'!', 'I', 161}, /* ¡ */
250 {'c', '|', 162}, /* ¢ */
251 {'c', 't', 162}, /* ¢ */
252 {'$', '$', 163}, /* £ */
253 {'P', 'd', 163}, /* £ */
254 {'o', 'x', 164}, /* ¤ */
255 {'C', 'u', 164}, /* ¤ */
256 {'C', 'u', 164}, /* ¤ */
257 {'E', 'u', 164}, /* ¤ */
258 {'Y', '-', 165}, /* ¥ */
259 {'Y', 'e', 165}, /* ¥ */
260 {'|', '|', 166}, /* ¦ */
261 {'B', 'B', 166}, /* ¦ */
262 {'p', 'a', 167}, /* § */
263 {'S', 'E', 167}, /* § */
264 {'"', '"', 168}, /* ¨ */
265 {'\'', ':', 168}, /* ¨ */
266 {'c', 'O', 169}, /* © */
267 {'C', 'o', 169}, /* © */
268 {'a', '-', 170}, /* ª */
269 {'<', '<', 171}, /* « */
270 {'-', ',', 172}, /* ¬ */
271 {'N', 'O', 172}, /* ¬ */
272 {'-', '-', 173}, /* ­ */
273 {'r', 'O', 174}, /* ® */
274 {'R', 'g', 174}, /* ® */
275 {'-', '=', 175}, /* ¯ */
276 {'\'', 'm', 175}, /* ¯ */
277 {'~', 'o', 176}, /* ° */
278 {'D', 'G', 176}, /* ° */
279 {'+', '-', 177}, /* ± */
280 {'2', '2', 178}, /* ² */
281 {'2', 'S', 178}, /* ² */
282 {'3', '3', 179}, /* ³ */
283 {'3', 'S', 179}, /* ³ */
284 {'\'', '\'', 180}, /* ´ */
285 {'j', 'u', 181}, /* µ */
286 {'M', 'y', 181}, /* µ */
287 {'p', 'p', 182}, /* ¶ */
288 {'P', 'I', 182}, /* ¶ */
289 {'~', '.', 183}, /* · */
290 {'.', 'M', 183}, /* · */
291 {',', ',', 184}, /* ¸ */
292 {'\'', ',', 184}, /* ¸ */
293 {'1', '1', 185}, /* ¹ */
294 {'1', 'S', 185}, /* ¹ */
295 {'o', '-', 186}, /* º */
296 {'>', '>', 187}, /* » */
297 {'1', '4', 188}, /* ¼ */
298 {'1', '2', 189}, /* ½ */
299 {'3', '4', 190}, /* ¾ */
300 {'~', '?', 191}, /* ¿ */
301 {'?', '?', 191}, /* ¿ */
302 {'?', 'I', 191}, /* ¿ */
303 {'A', '`', 192}, /* À */
304 {'A', '!', 192}, /* À */
305 {'A', '\'', 193}, /* Á */
306 {'A', '^', 194}, /* Â */
307 {'A', '>', 194}, /* Â */
308 {'A', '~', 195}, /* Ã */
309 {'A', '?', 195}, /* Ã */
310 {'A', '"', 196}, /* Ä */
311 {'A', ':', 196}, /* Ä */
312 {'A', '@', 197}, /* Å */
313 {'A', 'A', 197}, /* Å */
314 {'A', 'E', 198}, /* Æ */
315 {'C', ',', 199}, /* Ç */
316 {'E', '`', 200}, /* È */
317 {'E', '!', 200}, /* È */
318 {'E', '\'', 201}, /* É */
319 {'E', '^', 202}, /* Ê */
320 {'E', '>', 202}, /* Ê */
321 {'E', '"', 203}, /* Ë */
322 {'E', ':', 203}, /* Ë */
323 {'I', '`', 204}, /* Ì */
324 {'I', '!', 204}, /* Ì */
325 {'I', '\'', 205}, /* Í */
326 {'I', '^', 206}, /* Î */
327 {'I', '>', 206}, /* Î */
328 {'I', '"', 207}, /* Ï */
329 {'I', ':', 207}, /* Ï */
330 {'D', '-', 208}, /* Ð */
331 {'N', '~', 209}, /* Ñ */
332 {'N', '?', 209}, /* Ñ */
333 {'O', '`', 210}, /* Ò */
334 {'O', '!', 210}, /* Ò */
335 {'O', '\'', 211}, /* Ó */
336 {'O', '^', 212}, /* Ô */
337 {'O', '>', 212}, /* Ô */
338 {'O', '~', 213}, /* Õ */
339 {'O', '?', 213}, /* Õ */
340 {'O', '"', 214}, /* Ö */
341 {'O', ':', 214}, /* Ö */
342 {'/', '\\', 215}, /* × */
343 {'*', 'x', 215}, /* × */
344 {'O', '/', 216}, /* Ø */
345 {'U', '`', 217}, /* Ù */
346 {'U', '!', 217}, /* Ù */
347 {'U', '\'', 218}, /* Ú */
348 {'U', '^', 219}, /* Û */
349 {'U', '>', 219}, /* Û */
350 {'U', '"', 220}, /* Ü */
351 {'U', ':', 220}, /* Ü */
352 {'Y', '\'', 221}, /* Ý */
353 {'I', 'p', 222}, /* Þ */
354 {'T', 'H', 222}, /* Þ */
355 {'s', 's', 223}, /* ß */
356 {'s', '"', 223}, /* ß */
357 {'a', '`', 224}, /* à */
358 {'a', '!', 224}, /* à */
359 {'a', '\'', 225}, /* á */
360 {'a', '^', 226}, /* â */
361 {'a', '>', 226}, /* â */
362 {'a', '~', 227}, /* ã */
363 {'a', '?', 227}, /* ã */
364 {'a', '"', 228}, /* ä */
365 {'a', ':', 228}, /* ä */
366 {'a', 'a', 229}, /* å */
367 {'a', 'e', 230}, /* æ */
368 {'c', ',', 231}, /* ç */
369 {'e', '`', 232}, /* è */
370 {'e', '!', 232}, /* è */
371 {'e', '\'', 233}, /* é */
372 {'e', '^', 234}, /* ê */
373 {'e', '>', 234}, /* ê */
374 {'e', '"', 235}, /* ë */
375 {'e', ':', 235}, /* ë */
376 {'i', '`', 236}, /* ì */
377 {'i', '!', 236}, /* ì */
378 {'i', '\'', 237}, /* í */
379 {'i', '^', 238}, /* î */
380 {'i', '>', 238}, /* î */
381 {'i', '"', 239}, /* ï */
382 {'i', ':', 239}, /* ï */
383 {'d', '-', 240}, /* ð */
384 {'n', '~', 241}, /* ñ */
385 {'n', '?', 241}, /* ñ */
386 {'o', '`', 242}, /* ò */
387 {'o', '!', 242}, /* ò */
388 {'o', '\'', 243}, /* ó */
389 {'o', '^', 244}, /* ô */
390 {'o', '>', 244}, /* ô */
391 {'o', '~', 245}, /* õ */
392 {'o', '?', 245}, /* õ */
393 {'o', '"', 246}, /* ö */
394 {'o', ':', 246}, /* ö */
395 {':', '-', 247}, /* ÷ */
396 {'o', '/', 248}, /* ø */
397 {'u', '`', 249}, /* ù */
398 {'u', '!', 249}, /* ù */
399 {'u', '\'', 250}, /* ú */
400 {'u', '^', 251}, /* û */
401 {'u', '>', 251}, /* û */
402 {'u', '"', 252}, /* ü */
403 {'u', ':', 252}, /* ü */
404 {'y', '\'', 253}, /* ý */
405 {'i', 'p', 254}, /* þ */
406 {'t', 'h', 254}, /* þ */
407 {'y', '"', 255}, /* ÿ */
408 {'y', ':', 255}, /* ÿ */
409 {'"', '[', 196}, /* Ä */
410 {'"', '\\', 214}, /* Ö */
411 {'"', ']', 220}, /* Ü */
412 {'"', '{', 228}, /* ä */
413 {'"', '|', 246}, /* ö */
414 {'"', '}', 252}, /* ü */
415 {'"', '~', 223} /* ß */
416 };
417
418 #define RESIZE_FLAG_H 1
419 #define RESIZE_FLAG_V 2
420 #define RESIZE_FLAG_L 4
421
422 static char *resizeprompts[] = {
423 "resize # lines: ",
424 "resize -h # lines: ",
425 "resize -v # lines: ",
426 "resize -b # lines: ",
427 "resize -l # lines: ",
428 "resize -l -h # lines: ",
429 "resize -l -v # lines: ",
430 "resize -l -b # lines: ",
431 };
432
433 static int
434 parse_input_int(buf, len, val)
435 const char *buf;
436 int len;
437 int *val;
438 {
439 int x = 0, i;
440 if (len >= 1 && ((*buf == 'U' && buf[1] == '+') || (*buf == '0' && (buf[1] == 'x' || buf[1] == 'X'))))
441 {
442 x = 0;
443 for (i = 2; i < len; i++)
444 {
445 if (buf[i] >= '0' && buf[i] <= '9')
446 x = x * 16 | (buf[i] - '0');
447 else if (buf[i] >= 'a' && buf[i] <= 'f')
448 x = x * 16 | (buf[i] - ('a' - 10));
449 else if (buf[i] >= 'A' && buf[i] <= 'F')
450 x = x * 16 | (buf[i] - ('A' - 10));
451 else
452 return 0;
453 }
454 }
455 else if (buf[0] == '0')
456 {
457 x = 0;
458 for (i = 1; i < len; i++)
459 {
460 if (buf[i] < '0' || buf[i] > '7')
461 return 0;
462 x = x * 8 | (buf[i] - '0');
463 }
464 }
465 else
466 return 0;
467 *val = x;
468 return 1;
469 }
470
471 char *noargs[1];
472
473 void
474 InitKeytab()
475 {
476 register unsigned int i;
477 #ifdef MAPKEYS
478 char *argarr[2];
479 #endif
480
481 for (i = 0; i < sizeof(ktab)/sizeof(*ktab); i++)
482 {
483 ktab[i].nr = RC_ILLEGAL;
484 ktab[i].args = noargs;
485 ktab[i].argl = 0;
486 }
487 #ifdef MAPKEYS
488 for (i = 0; i < KMAP_KEYS+KMAP_AKEYS; i++)
489 {
490 umtab[i].nr = RC_ILLEGAL;
491 umtab[i].args = noargs;
492 umtab[i].argl = 0;
493 dmtab[i].nr = RC_ILLEGAL;
494 dmtab[i].args = noargs;
495 dmtab[i].argl = 0;
496 mmtab[i].nr = RC_ILLEGAL;
497 mmtab[i].args = noargs;
498 mmtab[i].argl = 0;
499 }
500 argarr[1] = 0;
501 for (i = 0; i < NKMAPDEF; i++)
502 {
503 if (i + KMAPDEFSTART < T_CAPS)
504 continue;
505 if (i + KMAPDEFSTART >= T_CAPS + KMAP_KEYS)
506 continue;
507 if (kmapdef[i] == 0)
508 continue;
509 argarr[0] = kmapdef[i];
510 SaveAction(dmtab + i + (KMAPDEFSTART - T_CAPS), RC_STUFF, argarr, 0);
511 }
512 for (i = 0; i < NKMAPADEF; i++)
513 {
514 if (i + KMAPADEFSTART < T_CURSOR)
515 continue;
516 if (i + KMAPADEFSTART >= T_CURSOR + KMAP_AKEYS)
517 continue;
518 if (kmapadef[i] == 0)
519 continue;
520 argarr[0] = kmapadef[i];
521 SaveAction(dmtab + i + (KMAPADEFSTART - T_CURSOR + KMAP_KEYS), RC_STUFF, argarr, 0);
522 }
523 for (i = 0; i < NKMAPMDEF; i++)
524 {
525 if (i + KMAPMDEFSTART < T_CAPS)
526 continue;
527 if (i + KMAPMDEFSTART >= T_CAPS + KMAP_KEYS)
528 continue;
529 if (kmapmdef[i] == 0)
530 continue;
531 argarr[0] = kmapmdef[i];
532 argarr[1] = 0;
533 SaveAction(mmtab + i + (KMAPMDEFSTART - T_CAPS), RC_STUFF, argarr, 0);
534 }
535 #endif
536
537 ktab['h'].nr = RC_HARDCOPY;
538 #ifdef BSDJOBS
539 ktab['z'].nr = ktab[Ctrl('z')].nr = RC_SUSPEND;
540 #endif
541 ktab['c'].nr = ktab[Ctrl('c')].nr = RC_SCREEN;
542 ktab[' '].nr = ktab[Ctrl(' ')].nr =
543 ktab['n'].nr = ktab[Ctrl('n')].nr = RC_NEXT;
544 ktab['N'].nr = RC_NUMBER;
545 ktab[Ctrl('h')].nr = ktab[0177].nr = ktab['p'].nr = ktab[Ctrl('p')].nr = RC_PREV;
546 ktab['k'].nr = ktab[Ctrl('k')].nr = RC_KILL;
547 ktab['l'].nr = ktab[Ctrl('l')].nr = RC_REDISPLAY;
548 ktab['w'].nr = ktab[Ctrl('w')].nr = RC_WINDOWS;
549 ktab['v'].nr = RC_VERSION;
550 ktab[Ctrl('v')].nr = RC_DIGRAPH;
551 ktab['q'].nr = ktab[Ctrl('q')].nr = RC_XON;
552 ktab['s'].nr = ktab[Ctrl('s')].nr = RC_XOFF;
553 ktab['t'].nr = ktab[Ctrl('t')].nr = RC_TIME;
554 ktab['i'].nr = ktab[Ctrl('i')].nr = RC_INFO;
555 ktab['m'].nr = ktab[Ctrl('m')].nr = RC_LASTMSG;
556 ktab['A'].nr = RC_TITLE;
557 #if defined(UTMPOK) && defined(LOGOUTOK)
558 ktab['L'].nr = RC_LOGIN;
559 #endif
560 ktab[','].nr = RC_LICENSE;
561 ktab['W'].nr = RC_WIDTH;
562 ktab['.'].nr = RC_DUMPTERMCAP;
563 ktab[Ctrl('\\')].nr = RC_QUIT;
564 #ifdef DETACH
565 ktab['d'].nr = ktab[Ctrl('d')].nr = RC_DETACH;
566 # ifdef POW_DETACH
567 ktab['D'].nr = RC_POW_DETACH;
568 # endif
569 #endif
570 ktab['r'].nr = ktab[Ctrl('r')].nr = RC_WRAP;
571 ktab['f'].nr = ktab[Ctrl('f')].nr = RC_FLOW;
572 ktab['C'].nr = RC_CLEAR;
573 ktab['Z'].nr = RC_RESET;
574 ktab['H'].nr = RC_LOG;
575 ktab['M'].nr = RC_MONITOR;
576 ktab['?'].nr = RC_HELP;
577 #ifdef MULTI
578 ktab['*'].nr = RC_DISPLAYS;
579 #endif
580 {
581 char *args[2];
582 args[0] = "-";
583 args[1] = NULL;
584 SaveAction(ktab + '-', RC_SELECT, args, 0);
585 }
586 for (i = 0; i < ((MAXWIN < 10) ? MAXWIN : 10); i++)
587 {
588 char *args[2], arg1[10];
589 args[0] = arg1;
590 args[1] = 0;
591 sprintf(arg1, "%d", i);
592 SaveAction(ktab + '0' + i, RC_SELECT, args, 0);
593 }
594 ktab['\''].nr = RC_SELECT; /* calling a window by name */
595 {
596 char *args[2];
597 args[0] = "-b";
598 args[1] = 0;
599 SaveAction(ktab + '"', RC_WINDOWLIST, args, 0);
600 }
601 ktab[Ctrl('G')].nr = RC_VBELL;
602 ktab[':'].nr = RC_COLON;
603 #ifdef COPY_PASTE
604 ktab['['].nr = ktab[Ctrl('[')].nr = RC_COPY;
605 {
606 char *args[2];
607 args[0] = ".";
608 args[1] = 0;
609 SaveAction(ktab + ']', RC_PASTE, args, 0);
610 SaveAction(ktab + Ctrl(']'), RC_PASTE, args, 0);
611 }
612 ktab['{'].nr = RC_HISTORY;
613 ktab['}'].nr = RC_HISTORY;
614 ktab['>'].nr = RC_WRITEBUF;
615 ktab['<'].nr = RC_READBUF;
616 ktab['='].nr = RC_REMOVEBUF;
617 #endif
618 #ifdef POW_DETACH
619 ktab['D'].nr = RC_POW_DETACH;
620 #endif
621 #ifdef LOCK
622 ktab['x'].nr = ktab[Ctrl('x')].nr = RC_LOCKSCREEN;
623 #endif
624 ktab['b'].nr = ktab[Ctrl('b')].nr = RC_BREAK;
625 ktab['B'].nr = RC_POW_BREAK;
626 ktab['_'].nr = RC_SILENCE;
627 ktab['S'].nr = RC_SPLIT;
628 ktab['Q'].nr = RC_ONLY;
629 ktab['X'].nr = RC_REMOVE;
630 ktab['F'].nr = RC_FIT;
631 ktab['\t'].nr = RC_FOCUS;
632 {
633 char *args[2];
634 args[0] = "up";
635 args[1] = 0;
636 SaveAction(ktab + T_BACKTAB - T_CAPS + 256, RC_FOCUS, args, 0);
637 }
638 {
639 char *args[2];
640 args[0] = "-v";
641 args[1] = 0;
642 SaveAction(ktab + '|', RC_SPLIT, args, 0);
643 }
644 /* These come last; they may want overwrite others: */
645 if (DefaultEsc >= 0)
646 {
647 ClearAction(&ktab[DefaultEsc]);
648 ktab[DefaultEsc].nr = RC_OTHER;
649 }
650 if (DefaultMetaEsc >= 0)
651 {
652 ClearAction(&ktab[DefaultMetaEsc]);
653 ktab[DefaultMetaEsc].nr = RC_META;
654 }
655
656 idleaction.nr = RC_BLANKER;
657 idleaction.args = noargs;
658 idleaction.argl = 0;
659 }
660
661 static struct action *
662 FindKtab(class, create)
663 char *class;
664 int create;
665 {
666 struct kclass *kp, **kpp;
667 int i;
668
669 if (class == 0)
670 return ktab;
671 for (kpp = &kclasses; (kp = *kpp) != 0; kpp = &kp->next)
672 if (!strcmp(kp->name, class))
673 break;
674 if (kp == 0)
675 {
676 if (!create)
677 return 0;
678 if (strlen(class) > 80)
679 {
680 Msg(0, "Command class name too long.");
681 return 0;
682 }
683 kp = malloc(sizeof(*kp));
684 if (kp == 0)
685 {
686 Msg(0, strnomem);
687 return 0;
688 }
689 kp->name = SaveStr(class);
690 for (i = 0; i < (int)(sizeof(kp->ktab)/sizeof(*kp->ktab)); i++)
691 {
692 kp->ktab[i].nr = RC_ILLEGAL;
693 kp->ktab[i].args = noargs;
694 }
695 kp->next = 0;
696 *kpp = kp;
697 }
698 return kp->ktab;
699 }
700
701 static void
702 ClearAction(act)
703 struct action *act;
704 {
705 char **p;
706
707 if (act->nr == RC_ILLEGAL)
708 return;
709 act->nr = RC_ILLEGAL;
710 if (act->args == noargs)
711 return;
712 for (p = act->args; *p; p++)
713 free(*p);
714 free((char *)act->args);
715 act->args = noargs;
716 act->argl = 0;
717 }
718
719 /*
720 * ProcessInput: process input from display and feed it into
721 * the layer on canvas D_forecv.
722 */
723
724 #ifdef MAPKEYS
725
726 /*
727 * This ProcessInput just does the keybindings and passes
728 * everything else on to ProcessInput2.
729 */
730
731 void
732 ProcessInput(ibuf, ilen)
733 char *ibuf;
734 int ilen;
735 {
736 int ch, slen;
737 unsigned char *s, *q;
738 int i, l;
739 char *p;
740
741 debug1("ProcessInput: %d bytes\n", ilen);
742 if (display == 0 || ilen == 0)
743 return;
744 if (D_seql)
745 evdeq(&D_mapev);
746 slen = ilen;
747 s = (unsigned char *)ibuf;
748 while (ilen-- > 0)
749 {
750 ch = *s++;
751 if (D_dontmap || !D_nseqs)
752 {
753 D_dontmap = 0;
754 continue;
755 }
756 for (;;)
757 {
758 debug3("cmp %c %c[%d]\n", ch, *D_seqp, D_seqp - D_kmaps);
759 if (*D_seqp != ch)
760 {
761 l = D_seqp[D_seqp[-D_seql-1] + 1];
762 if (l)
763 {
764 D_seqp += l * 2 + 4;
765 debug1("miss %d\n", D_seqp - D_kmaps);
766 continue;
767 }
768 debug("complete miss\n");
769 D_mapdefault = 0;
770 l = D_seql;
771 p = (char *)D_seqp - l;
772 D_seql = 0;
773 D_seqp = D_kmaps + 3;
774 if (l == 0)
775 break;
776 if ((q = D_seqh) != 0)
777 {
778 D_seqh = 0;
779 i = q[0] << 8 | q[1];
780 i &= ~KMAP_NOTIMEOUT;
781 debug1("Mapping former hit #%d - ", i);
782 debug2("%d(%s) - ", q[2], q + 3);
783 if (StuffKey(i))
784 ProcessInput2((char *)q + 3, q[2]);
785 if (display == 0)
786 return;
787 l -= q[2];
788 p += q[2];
789 }
790 else
791 D_dontmap = 1;
792 debug1("flush old %d\n", l);
793 ProcessInput(p, l);
794 if (display == 0)
795 return;
796 evdeq(&D_mapev);
797 continue;
798 }
799 if (D_seql++ == 0)
800 {
801 /* Finish old stuff */
802 slen -= ilen + 1;
803 debug1("finish old %d\n", slen);
804 if (slen)
805 ProcessInput2(ibuf, slen);
806 if (display == 0)
807 return;
808 D_seqh = 0;
809 }
810 ibuf = (char *)s;
811 slen = ilen;
812 D_seqp++;
813 l = D_seql;
814 debug2("length am %d, want %d\n", l, D_seqp[-l - 1]);
815 if (l == D_seqp[-l - 1])
816 {
817 if (D_seqp[l] != l)
818 {
819 q = D_seqp + 1 + l;
820 if (D_kmaps + D_nseqs > q && q[2] > l && !bcmp(D_seqp - l, q + 3, l))
821 {
822 debug1("have another mapping (%s), delay execution\n", q + 3);
823 D_seqh = D_seqp - 3 - l;
824 D_seqp = q + 3 + l;
825 break;
826 }
827 }
828 i = D_seqp[-l - 3] << 8 | D_seqp[-l - 2];
829 i &= ~KMAP_NOTIMEOUT;
830 debug1("Mapping #%d - ", i);
831 p = (char *)D_seqp - l;
832 debug2("%d(%s) - ", l, p);
833 D_seql = 0;
834 D_seqp = D_kmaps + 3;
835 D_seqh = 0;
836 if (StuffKey(i))
837 ProcessInput2(p, l);
838 if (display == 0)
839 return;
840 }
841 break;
842 }
843 }
844 if (D_seql)
845 {
846 debug("am in sequence -> check for timeout\n");
847 l = D_seql;
848 for (s = D_seqp; ; s += i * 2 + 4)
849 {
850 if (s[-l-3] & KMAP_NOTIMEOUT >> 8)
851 break;
852 if ((i = s[s[-l-1] + 1]) == 0)
853 {
854 SetTimeout(&D_mapev, maptimeout);
855 evenq(&D_mapev);
856 break;
857 }
858 }
859 }
860 ProcessInput2(ibuf, slen);
861 }
862
863 #else
864 # define ProcessInput2 ProcessInput
865 #endif
866
867
868 /*
869 * Here only the screen escape commands are handled.
870 */
871
872 void
873 ProcessInput2(ibuf, ilen)
874 char *ibuf;
875 int ilen;
876 {
877 char *s;
878 int ch, slen;
879 struct action *ktabp;
880
881 debug1("ProcessInput2: %d bytes\n", ilen);
882 while (ilen && display)
883 {
884 debug1(" - ilen now %d bytes\n", ilen);
885 flayer = D_forecv->c_layer;
886 fore = D_fore;
887 slen = ilen;
888 s = ibuf;
889 if (!D_ESCseen)
890 {
891 while (ilen > 0)
892 {
893 if ((unsigned char)*s++ == D_user->u_Esc)
894 break;
895 ilen--;
896 }
897 slen -= ilen;
898 if (slen)
899 DoProcess(fore, &ibuf, &slen, 0);
900 if (--ilen == 0)
901 D_ESCseen = ktab;
902 }
903 if (ilen <= 0)
904 return;
905 ktabp = D_ESCseen ? D_ESCseen : ktab;
906 D_ESCseen = 0;
907 ch = (unsigned char)*s;
908
909 /*
910 * As users have different esc characters, but a common ktab[],
911 * we fold back the users esc and meta-esc key to the Default keys
912 * that can be looked up in the ktab[]. grmbl. jw.
913 * XXX: make ktab[] a per user thing.
914 */
915 if (ch == D_user->u_Esc)
916 ch = DefaultEsc;
917 else if (ch == D_user->u_MetaEsc)
918 ch = DefaultMetaEsc;
919
920 if (ch >= 0)
921 DoAction(&ktabp[ch], ch);
922 ibuf = (char *)(s + 1);
923 ilen--;
924 }
925 }
926
927 void
928 DoProcess(p, bufp, lenp, pa)
929 struct win *p;
930 char **bufp;
931 int *lenp;
932 struct paster *pa;
933 {
934 int oldlen;
935 struct display *d = display;
936
937 #ifdef COPY_PASTE
938 /* XXX -> PasteStart */
939 if (pa && *lenp > 1 && p && p->w_slowpaste)
940 {
941 /* schedule slowpaste event */
942 SetTimeout(&p->w_paster.pa_slowev, p->w_slowpaste);
943 evenq(&p->w_paster.pa_slowev);
944 return;
945 }
946 #endif
947 while (flayer && *lenp)
948 {
949 #ifdef COPY_PASTE
950 if (!pa && p && p->w_paster.pa_pastelen && flayer == p->w_paster.pa_pastelayer)
951 {
952 debug("layer is busy - beep!\n");
953 WBell(p, visual_bell);
954 *bufp += *lenp;
955 *lenp = 0;
956 display = d;
957 return;
958 }
959 #endif
960 oldlen = *lenp;
961 LayProcess(bufp, lenp);
962 #ifdef COPY_PASTE
963 if (pa && !pa->pa_pastelayer)
964 break; /* flush rest of paste */
965 #endif
966 if (*lenp == oldlen)
967 {
968 if (pa)
969 {
970 display = d;
971 return;
972 }
973 /* We're full, let's beep */
974 debug("layer is full - beep!\n");
975 WBell(p, visual_bell);
976 break;
977 }
978 }
979 *bufp += *lenp;
980 *lenp = 0;
981 display = d;
982 #ifdef COPY_PASTE
983 if (pa && pa->pa_pastelen == 0)
984 FreePaster(pa);
985 #endif
986 }
987
988 int
989 FindCommnr(str)
990 char *str;
991 {
992 int x, m, l = 0, r = RC_LAST;
993 while (l <= r)
994 {
995 m = (l + r) / 2;
996 x = strcmp(str, comms[m].name);
997 if (x > 0)
998 l = m + 1;
999 else if (x < 0)
1000 r = m - 1;
1001 else
1002 return m;
1003 }
1004 return RC_ILLEGAL;
1005 }
1006
1007 static int
1008 CheckArgNum(nr, args)
1009 int nr;
1010 char **args;
1011 {
1012 int i, n;
1013 static char *argss[] = {"no", "one", "two", "three", "four", "OOPS"};
1014 static char *orformat[] =
1015 {
1016 "%s: %s: %s argument%s required",
1017 "%s: %s: %s or %s argument%s required",
1018 "%s: %s: %s, %s or %s argument%s required",
1019 "%s: %s: %s, %s, %s or %s argument%s required"
1020 };
1021
1022 n = comms[nr].flags & ARGS_MASK;
1023 for (i = 0; args[i]; i++)
1024 ;
1025 if (comms[nr].flags & ARGS_ORMORE)
1026 {
1027 if (i < n)
1028 {
1029 Msg(0, "%s: %s: at least %s argument%s required",
1030 rc_name, comms[nr].name, argss[n], n != 1 ? "s" : "");
1031 return -1;
1032 }
1033 }
1034 else if ((comms[nr].flags & ARGS_PLUS1) &&
1035 (comms[nr].flags & ARGS_PLUS2) &&
1036 (comms[nr].flags & ARGS_PLUS3))
1037 {
1038 if (i != n && i != n + 1 && i != n + 2 && i != n + 3)
1039 {
1040 Msg(0, orformat[3], rc_name, comms[nr].name, argss[n],
1041 argss[n + 1], argss[n + 2], argss[n + 3], "");
1042 return -1;
1043 }
1044 }
1045 else if ((comms[nr].flags & ARGS_PLUS1) &&
1046 (comms[nr].flags & ARGS_PLUS2))
1047 {
1048 if (i != n && i != n + 1 && i != n + 2)
1049 {
1050 Msg(0, orformat[2], rc_name, comms[nr].name, argss[n],
1051 argss[n + 1], argss[n + 2], "");
1052 return -1;
1053 }
1054 }
1055 else if ((comms[nr].flags & ARGS_PLUS1) &&
1056 (comms[nr].flags & ARGS_PLUS3))
1057 {
1058 if (i != n && i != n + 1 && i != n + 3)
1059 {
1060 Msg(0, orformat[2], rc_name, comms[nr].name, argss[n],
1061 argss[n + 1], argss[n + 3], "");
1062 return -1;
1063 }
1064 }
1065 else if ((comms[nr].flags & ARGS_PLUS2) &&
1066 (comms[nr].flags & ARGS_PLUS3))
1067 {
1068 if (i != n && i != n + 2 && i != n + 3)
1069 {
1070 Msg(0, orformat[2], rc_name, comms[nr].name, argss[n],
1071 argss[n + 2], argss[n + 3], "");
1072 return -1;
1073 }
1074 }
1075 else if (comms[nr].flags & ARGS_PLUS1)
1076 {
1077 if (i != n && i != n + 1)
1078 {
1079 Msg(0, orformat[1], rc_name, comms[nr].name, argss[n],
1080 argss[n + 1], n != 0 ? "s" : "");
1081 return -1;
1082 }
1083 }
1084 else if (comms[nr].flags & ARGS_PLUS2)
1085 {
1086 if (i != n && i != n + 2)
1087 {
1088 Msg(0, orformat[1], rc_name, comms[nr].name, argss[n],
1089 argss[n + 2], "s");
1090 return -1;
1091 }
1092 }
1093 else if (comms[nr].flags & ARGS_PLUS3)
1094 {
1095 if (i != n && i != n + 3)
1096 {
1097 Msg(0, orformat[1], rc_name, comms[nr].name, argss[n],
1098 argss[n + 3], "");
1099 return -1;
1100 }
1101 }
1102 else if (i != n)
1103 {
1104 Msg(0, orformat[0], rc_name, comms[nr].name, argss[n], n != 1 ? "s" : "");
1105 return -1;
1106 }
1107 return i;
1108 }
1109
1110 static void
1111 StuffFin(buf, len, data)
1112 char *buf;
1113 int len;
1114 char *data;
1115 {
1116 if (!flayer)
1117 return;
1118 while(len)
1119 LayProcess(&buf, &len);
1120 }
1121
1122 /*ARGSUSED*/
1123 void
1124 DoAction(act, key)
1125 struct action *act;
1126 int key;
1127 {
1128 int nr = act->nr;
1129 char **args = act->args;
1130 int *argl = act->argl;
1131 struct win *p;
1132 int argc, i, n, msgok;
1133 char *s;
1134 char ch;
1135 struct display *odisplay = display;
1136 struct acluser *user;
1137
1138 user = display ? D_user : users;
1139 if (nr == RC_ILLEGAL)
1140 {
1141 debug1("key '%c': No action\n", key);
1142 return;
1143 }
1144 n = comms[nr].flags;
1145 if ((n & NEED_DISPLAY) && display == 0)
1146 {
1147 Msg(0, "%s: %s: display required", rc_name, comms[nr].name);
1148 return;
1149 }
1150 if ((n & NEED_FORE) && fore == 0)
1151 {
1152 Msg(0, "%s: %s: window required", rc_name, comms[nr].name);
1153 return;
1154 }
1155 if ((n & NEED_LAYER) && flayer == 0)
1156 {
1157 Msg(0, "%s: %s: display or window required", rc_name, comms[nr].name);
1158 return;
1159 }
1160 if ((argc = CheckArgNum(nr, args)) < 0)
1161 return;
1162 #ifdef MULTIUSER
1163 if (display)
1164 {
1165 if (AclCheckPermCmd(D_user, ACL_EXEC, &comms[nr]))
1166 {
1167 Msg(0, "%s: %s: permission denied (user %s)",
1168 rc_name, comms[nr].name, (EffectiveAclUser ? EffectiveAclUser : D_user)->u_name);
1169 return;
1170 }
1171 }
1172 #endif /* MULTIUSER */
1173
1174 msgok = display && !*rc_name;
1175 switch(nr)
1176 {
1177 case RC_SELECT:
1178 if (!*args)
1179 InputSelect();
1180 else if (args[0][0] == '-' && !args[0][1])
1181 {
1182 SetForeWindow((struct win *)0);
1183 Activate(0);
1184 }
1185 else if (args[0][0] == '.' && !args[0][1])
1186 {
1187 if (!fore)
1188 Msg(0, "select . needs a window");
1189 else
1190 {
1191 SetForeWindow(fore);
1192 Activate(0);
1193 }
1194 }
1195 else if (ParseWinNum(act, &n) == 0)
1196 SwitchWindow(n);
1197 break;
1198 #ifdef AUTO_NUKE
1199 case RC_DEFAUTONUKE:
1200 if (ParseOnOff(act, &defautonuke) == 0 && msgok)
1201 Msg(0, "Default autonuke turned %s", defautonuke ? "on" : "off");
1202 if (display && *rc_name)
1203 D_auto_nuke = defautonuke;
1204 break;
1205 case RC_AUTONUKE:
1206 if (ParseOnOff(act, &D_auto_nuke) == 0 && msgok)
1207 Msg(0, "Autonuke turned %s", D_auto_nuke ? "on" : "off");
1208 break;
1209 #endif
1210 case RC_DEFOBUFLIMIT:
1211 if (ParseNum(act, &defobuflimit) == 0 && msgok)
1212 Msg(0, "Default limit set to %d", defobuflimit);
1213 if (display && *rc_name)
1214 {
1215 D_obufmax = defobuflimit;
1216 D_obuflenmax = D_obuflen - D_obufmax;
1217 }
1218 break;
1219 case RC_OBUFLIMIT:
1220 if (*args == 0)
1221 Msg(0, "Limit is %d, current buffer size is %d", D_obufmax, D_obuflen);
1222 else if (ParseNum(act, &D_obufmax) == 0 && msgok)
1223 Msg(0, "Limit set to %d", D_obufmax);
1224 D_obuflenmax = D_obuflen - D_obufmax;
1225 break;
1226 case RC_DUMPTERMCAP:
1227 WriteFile(user, (char *)0, DUMP_TERMCAP);
1228 break;
1229 case RC_HARDCOPY:
1230 {
1231 int mode = DUMP_HARDCOPY;
1232
1233 if (argc > 1 && !strcmp(*args, "-h"))
1234 {
1235 mode = DUMP_SCROLLBACK;
1236 args++;
1237 argc--;
1238 }
1239 if (*args && args[1])
1240 {
1241 Msg(0, "%s: hardcopy: too many arguments", rc_name);
1242 break;
1243 }
1244 if (fore == 0 && *args == 0)
1245 Msg(0, "%s: hardcopy: window required", rc_name);
1246 else
1247 WriteFile(user, *args, mode);
1248 }
1249 break;
1250 case RC_DEFLOG:
1251 (void)ParseOnOff(act, &nwin_default.Lflag);
1252 break;
1253 case RC_LOG:
1254 n = fore->w_log ? 1 : 0;
1255 ParseSwitch(act, &n);
1256 LogToggle(n);
1257 break;
1258 #ifdef BSDJOBS
1259 case RC_SUSPEND:
1260 Detach(D_STOP);
1261 break;
1262 #endif
1263 case RC_NEXT:
1264 if (MoreWindows())
1265 SwitchWindow(NextWindow());
1266 break;
1267 case RC_PREV:
1268 if (MoreWindows())
1269 SwitchWindow(PreviousWindow());
1270 break;
1271 case RC_KILL:
1272 {
1273 char *name;
1274
1275 if (key >= 0)
1276 {
1277 #ifdef PSEUDOS
1278 Input(fore->w_pwin ? "Really kill this filter [y/n]" : "Really kill this window [y/n]", 1, INP_RAW, confirm_fn, NULL, RC_KILL);
1279 #else
1280 Input("Really kill this window [y/n]", 1, INP_RAW, confirm_fn, NULL, RC_KILL);
1281 #endif
1282 break;
1283 }
1284 n = fore->w_number;
1285 #ifdef PSEUDOS
1286 if (fore->w_pwin)
1287 {
1288 FreePseudowin(fore);
1289 Msg(0, "Filter removed.");
1290 break;
1291 }
1292 #endif
1293 name = SaveStr(fore->w_title);
1294 KillWindow(fore);
1295 Msg(0, "Window %d (%s) killed.", n, name);
1296 if (name)
1297 free(name);
1298 break;
1299 }
1300 case RC_QUIT:
1301 if (key >= 0)
1302 {
1303 Input("Really quit and kill all your windows [y/n]", 1, INP_RAW, confirm_fn, NULL, RC_QUIT);
1304 break;
1305 }
1306 Finit(0);
1307 /* NOTREACHED */
1308 #ifdef DETACH
1309 case RC_DETACH:
1310 if (*args && !strcmp(*args, "-h"))
1311 Hangup();
1312 else
1313 Detach(D_DETACH);
1314 break;
1315 # ifdef POW_DETACH
1316 case RC_POW_DETACH:
1317 if (key >= 0)
1318 {
1319 static char buf[2];
1320
1321 buf[0] = key;
1322 Input(buf, 1, INP_RAW, pow_detach_fn, NULL, 0);
1323 }
1324 else
1325 Detach(D_POWER); /* detach and kill Attacher's parent */
1326 break;
1327 # endif
1328 #endif
1329 case RC_DEBUG:
1330 #ifdef DEBUG
1331 if (!*args)
1332 {
1333 if (dfp)
1334 Msg(0, "debugging info is written to %s/", DEBUGDIR);
1335 else
1336 Msg(0, "debugging is currently off. Use 'debug on' to enable.");
1337 break;
1338 }
1339 if (dfp)
1340 {
1341 debug("debug: closing debug file.\n");
1342 fflush(dfp);
1343 fclose(dfp);
1344 dfp = NULL;
1345 }
1346 if (strcmp("off", *args))
1347 opendebug(0, 1);
1348 # ifdef SIG_NODEBUG
1349 else if (display)
1350 kill(D_userpid, SIG_NODEBUG); /* a one shot item, but hey... */
1351 # endif /* SIG_NODEBUG */
1352 #else
1353 if (*args == 0 || strcmp("off", *args))
1354 Msg(0, "Sorry, screen was compiled without -DDEBUG option.");
1355 #endif
1356 break;
1357 #ifdef ZMODEM
1358 case RC_ZMODEM:
1359 if (*args && !strcmp(*args, "sendcmd"))
1360 {
1361 if (args[1])
1362 {
1363 free(zmodem_sendcmd);
1364 zmodem_sendcmd = SaveStr(args[1]);
1365 }
1366 if (msgok)
1367 Msg(0, "zmodem sendcmd: %s", zmodem_sendcmd);
1368 break;
1369 }
1370 if (*args && !strcmp(*args, "recvcmd"))
1371 {
1372 if (args[1])
1373 {
1374 free(zmodem_recvcmd);
1375 zmodem_recvcmd = SaveStr(args[1]);
1376 }
1377 if (msgok)
1378 Msg(0, "zmodem recvcmd: %s", zmodem_recvcmd);
1379 break;
1380 }
1381 if (*args)
1382 {
1383 for (i = 0; i < 4; i++)
1384 if (!strcmp(zmodes[i], *args))
1385 break;
1386 if (i == 4 && !strcmp(*args, "on"))
1387 i = 1;
1388 if (i == 4)
1389 {
1390 Msg(0, "usage: zmodem off|auto|catch|pass");
1391 break;
1392 }
1393 zmodem_mode = i;
1394 }
1395 if (msgok)
1396 Msg(0, "zmodem mode is %s", zmodes[zmodem_mode]);
1397 break;
1398 #endif
1399 case RC_ZOMBIE:
1400 {
1401 if (!(s = *args))
1402 {
1403 ZombieKey_destroy = 0;
1404 break;
1405 }
1406 if (*argl == 0 || *argl > 2)
1407 {
1408 Msg(0, "%s:zombie: one or two characters expected.", rc_name);
1409 break;
1410 }
1411 if (args[1])
1412 {
1413 if (!strcmp(args[1], "onerror"))
1414 {
1415 ZombieKey_onerror = 1;
1416 } else {
1417 Msg(0, "usage: zombie [keys [onerror]]");
1418 break;
1419 }
1420 } else
1421 ZombieKey_onerror = 0;
1422 ZombieKey_destroy = args[0][0];
1423 ZombieKey_resurrect = *argl == 2 ? args[0][1] : 0;
1424 }
1425 break;
1426 case RC_WALL:
1427 #ifdef MULTIUSER
1428 s = D_user->u_name;
1429 #else
1430 s = D_usertty;
1431 #endif
1432 {
1433 struct display *olddisplay = display;
1434 display = 0; /* no display will cause a broadcast */
1435 Msg(0, "%s: %s", s, *args);
1436 display = olddisplay;
1437 }
1438 break;
1439 case RC_AT:
1440 /* where this AT command comes from: */
1441 #ifdef MULTIUSER
1442 s = SaveStr(D_user->u_name);
1443 /* DO NOT RETURN FROM HERE WITHOUT RESETTING THIS: */
1444 EffectiveAclUser = D_user;
1445 #else
1446 s = SaveStr(D_usertty);
1447 #endif
1448 n = strlen(args[0]);
1449 if (n) n--;
1450 /*
1451 * the windows/displays loops are quite dangerous here, take extra
1452 * care not to trigger landmines. Things may appear/disappear while
1453 * we are walking along.
1454 */
1455 switch (args[0][n])
1456 {
1457 case '*': /* user */
1458 {
1459 struct display *nd;
1460 struct acluser *u;
1461
1462 if (!n)
1463 u = D_user;
1464 else
1465 for (u = users; u; u = u->u_next)
1466 {
1467 debug3("strncmp('%s', '%s', %d)\n", *args, u->u_name, n);
1468 if (!strncmp(*args, u->u_name, n))
1469 break;
1470 }
1471 debug1("at all displays of user %s\n", u->u_name);
1472 for (display = displays; display; display = nd)
1473 {
1474 nd = display->d_next;
1475 if (D_forecv == 0)
1476 continue;
1477 flayer = D_forecv->c_layer;
1478 fore = D_fore;
1479 if (D_user != u)
1480 continue;
1481 debug1("AT display %s\n", D_usertty);
1482 DoCommand(args + 1, argl + 1);
1483 if (display)
1484 Msg(0, "command from %s: %s %s",
1485 s, args[1], args[2] ? args[2] : "");
1486 display = NULL;
1487 flayer = 0;
1488 fore = NULL;
1489 }
1490 break;
1491 }
1492 case '%': /* display */
1493 {
1494 struct display *nd;
1495
1496 debug1("at display matching '%s'\n", args[0]);
1497 for (display = displays; display; display = nd)
1498 {
1499 nd = display->d_next;
1500 if (D_forecv == 0)
1501 continue;
1502 fore = D_fore;
1503 flayer = D_forecv->c_layer;
1504 if (strncmp(args[0], D_usertty, n) &&
1505 (strncmp("/dev/", D_usertty, 5) ||
1506 strncmp(args[0], D_usertty + 5, n)) &&
1507 (strncmp("/dev/tty", D_usertty, 8) ||
1508 strncmp(args[0], D_usertty + 8, n)))
1509 continue;
1510 debug1("AT display %s\n", D_usertty);
1511 DoCommand(args + 1, argl + 1);
1512 if (display)
1513 Msg(0, "command from %s: %s %s",
1514 s, args[1], args[2] ? args[2] : "");
1515 display = NULL;
1516 fore = NULL;
1517 flayer = 0;
1518 }
1519 break;
1520 }
1521 case '#': /* window */
1522 n--;
1523 /* FALLTHROUGH */
1524 default:
1525 {
1526 struct win *nw;
1527 int ch;
1528
1529 n++;
1530 ch = args[0][n];
1531 args[0][n] = '\0';
1532 if (!*args[0] || (i = WindowByNumber(args[0])) < 0)
1533 {
1534 args[0][n] = ch; /* must restore string in case of bind */
1535 /* try looping over titles */
1536 for (fore = windows; fore; fore = nw)
1537 {
1538 nw = fore->w_next;
1539 if (strncmp(args[0], fore->w_title, n))
1540 continue;
1541 debug2("AT window %d(%s)\n", fore->w_number, fore->w_title);
1542 /*
1543 * consider this a bug or a feature:
1544 * while looping through windows, we have fore AND
1545 * display context. This will confuse users who try to
1546 * set up loops inside of loops, but often allows to do
1547 * what you mean, even when you adress your context wrong.
1548 */
1549 i = 0;
1550 /* XXX: other displays? */
1551 if (fore->w_layer.l_cvlist)
1552 display = fore->w_layer.l_cvlist->c_display;
1553 flayer = fore->w_savelayer ? fore->w_savelayer : &fore->w_layer;
1554 DoCommand(args + 1, argl + 1); /* may destroy our display */
1555 if (fore && fore->w_layer.l_cvlist)
1556 {
1557 display = fore->w_layer.l_cvlist->c_display;
1558 Msg(0, "command from %s: %s %s",
1559 s, args[1], args[2] ? args[2] : "");
1560 }
1561 }
1562 display = NULL;
1563 fore = NULL;
1564 if (i < 0)
1565 Msg(0, "%s: at '%s': no such window.\n", rc_name, args[0]);
1566 break;
1567 }
1568 else if (i < MAXWIN && (fore = wtab[i]))
1569 {
1570 args[0][n] = ch; /* must restore string in case of bind */
1571 debug2("AT window %d (%s)\n", fore->w_number, fore->w_title);
1572 if (fore->w_layer.l_cvlist)
1573 display = fore->w_layer.l_cvlist->c_display;
1574 flayer = fore->w_savelayer ? fore->w_savelayer : &fore->w_layer;
1575 DoCommand(args + 1, argl + 1);
1576 if (fore && fore->w_layer.l_cvlist)
1577 {
1578 display = fore->w_layer.l_cvlist->c_display;
1579 Msg(0, "command from %s: %s %s",
1580 s, args[1], args[2] ? args[2] : "");
1581 }
1582 display = NULL;
1583 fore = NULL;
1584 }
1585 else
1586 Msg(0, "%s: at [identifier][%%|*|#] command [args]", rc_name);
1587 break;
1588 }
1589 }
1590 free(s);
1591 #ifdef MULTIUSER
1592 EffectiveAclUser = NULL;
1593 #endif
1594 break;
1595
1596 #ifdef COPY_PASTE
1597 case RC_READREG:
1598 #ifdef ENCODINGS
1599 i = fore ? fore->w_encoding : display ? display->d_encoding : 0;
1600 if (args[0] && args[1] && !strcmp(args[0], "-e"))
1601 {
1602 i = FindEncoding(args[1]);
1603 if (i == -1)
1604 {
1605 Msg(0, "%s: readreg: unknown encoding", rc_name);
1606 break;
1607 }
1608 args += 2;
1609 }
1610 #endif
1611 /*
1612 * Without arguments we prompt for a destination register.
1613 * It will receive the copybuffer contents.
1614 * This is not done by RC_PASTE, as we prompt for source
1615 * (not dest) there.
1616 */
1617 if ((s = *args) == NULL)
1618 {
1619 Input("Copy to register:", 1, INP_RAW, copy_reg_fn, NULL, 0);
1620 break;
1621 }
1622 if (*argl != 1)
1623 {
1624 Msg(0, "%s: copyreg: character, ^x, or (octal) \\032 expected.", rc_name);
1625 break;
1626 }
1627 ch = args[0][0];
1628 /*
1629 * With two arguments we *really* read register contents from file
1630 */
1631 if (args[1])
1632 {
1633 if (args[2])
1634 {
1635 Msg(0, "%s: readreg: too many arguments", rc_name);
1636 break;
1637 }
1638 if ((s = ReadFile(args[1], &n)))
1639 {
1640 struct plop *pp = plop_tab + (int)(unsigned char)ch;
1641
1642 if (pp->buf)
1643 free(pp->buf);
1644 pp->buf = s;
1645 pp->len = n;
1646 #ifdef ENCODINGS
1647 pp->enc = i;
1648 #endif
1649 }
1650 }
1651 else
1652 /*
1653 * with one argument we copy the copybuffer into a specified register
1654 * This could be done with RC_PASTE too, but is here to be consistent
1655 * with the zero argument call.
1656 */
1657 copy_reg_fn(&ch, 0, NULL);
1658 break;
1659 #endif
1660 case RC_REGISTER:
1661 #ifdef ENCODINGS
1662 i = fore ? fore->w_encoding : display ? display->d_encoding : 0;
1663 if (args[0] && args[1] && !strcmp(args[0], "-e"))
1664 {
1665 i = FindEncoding(args[1]);
1666 if (i == -1)
1667 {
1668 Msg(0, "%s: register: unknown encoding", rc_name);
1669 break;
1670 }
1671 args += 2;
1672 argc -= 2;
1673 }
1674 #endif
1675 if (argc != 2)
1676 {
1677 Msg(0, "%s: register: illegal number of arguments.", rc_name);
1678 break;
1679 }
1680 if (*argl != 1)
1681 {
1682 Msg(0, "%s: register: character, ^x, or (octal) \\032 expected.", rc_name);
1683 break;
1684 }
1685 ch = args[0][0];
1686 #ifdef COPY_PASTE
1687 if (ch == '.')
1688 {
1689 if (user->u_plop.buf != NULL)
1690 UserFreeCopyBuffer(user);
1691 if (args[1] && args[1][0])
1692 {
1693 user->u_plop.buf = SaveStrn(args[1], argl[1]);
1694 user->u_plop.len = argl[1];
1695 #ifdef ENCODINGS
1696 user->u_plop.enc = i;
1697 #endif
1698 }
1699 }
1700 else
1701 #endif
1702 {
1703 struct plop *plp = plop_tab + (int)(unsigned char)ch;
1704
1705 if (plp->buf)
1706 free(plp->buf);
1707 plp->buf = SaveStrn(args[1], argl[1]);
1708 plp->len = argl[1];
1709 #ifdef ENCODINGS
1710 plp->enc = i;
1711 #endif
1712 }
1713 break;
1714 case RC_PROCESS:
1715 if ((s = *args) == NULL)
1716 {
1717 Input("Process register:", 1, INP_RAW, process_fn, NULL, 0);
1718 break;
1719 }
1720 if (*argl != 1)
1721 {
1722 Msg(0, "%s: process: character, ^x, or (octal) \\032 expected.", rc_name);
1723 break;
1724 }
1725 ch = args[0][0];
1726 process_fn(&ch, 0, NULL);
1727 break;
1728 case RC_STUFF:
1729 s = *args;
1730 if (!args[0])
1731 {
1732 Input("Stuff:", 100, INP_COOKED, StuffFin, NULL, 0);
1733 break;
1734 }
1735 n = *argl;
1736 if (args[1])
1737 {
1738 if (strcmp(s, "-k"))
1739 {
1740 Msg(0, "%s: stuff: invalid option %s", rc_name, s);
1741 break;
1742 }
1743 s = args[1];
1744 for (i = T_CAPS; i < T_OCAPS; i++)
1745 if (strcmp(term[i].tcname, s) == 0)
1746 break;
1747 if (i == T_OCAPS)
1748 {
1749 Msg(0, "%s: stuff: unknown key '%s'", rc_name, s);
1750 break;
1751 }
1752 #ifdef MAPKEYS
1753 if (StuffKey(i - T_CAPS) == 0)
1754 break;
1755 #endif
1756 s = display ? D_tcs[i].str : 0;
1757 if (s == 0)
1758 break;
1759 n = strlen(s);
1760 }
1761 while(n)
1762 LayProcess(&s, &n);
1763 break;
1764 case RC_REDISPLAY:
1765 Activate(-1);
1766 break;
1767 case RC_WINDOWS:
1768 ShowWindows(-1);
1769 break;
1770 case RC_VERSION:
1771 Msg(0, "screen %s", version);
1772 break;
1773 case RC_TIME:
1774 if (*args)
1775 {
1776 timestring = SaveStr(*args);
1777 break;
1778 }
1779 Msg(0, "%s", MakeWinMsg(timestring, fore, '%'));
1780 break;
1781 case RC_INFO:
1782 ShowInfo();
1783 break;
1784 case RC_DINFO:
1785 ShowDInfo();
1786 break;
1787 case RC_COMMAND:
1788 {
1789 struct action *ktabp = ktab;
1790 if (argc == 2 && !strcmp(*args, "-c"))
1791 {
1792 if ((ktabp = FindKtab(args[1], 0)) == 0)
1793 {
1794 Msg(0, "Unknown command class '%s'", args[1]);
1795 break;
1796 }
1797 }
1798 if (D_ESCseen != ktab || ktabp != ktab)
1799 {
1800 D_ESCseen = ktabp;
1801 break;
1802 }
1803 D_ESCseen = 0;
1804 }
1805 /* FALLTHROUGH */
1806 case RC_OTHER:
1807 if (MoreWindows())
1808 SwitchWindow(display && D_other ? D_other->w_number : NextWindow());
1809 break;
1810 case RC_META:
1811 if (user->u_Esc == -1)
1812 break;
1813 ch = user->u_Esc;
1814 s = &ch;
1815 n = 1;
1816 LayProcess(&s, &n);
1817 break;
1818 case RC_XON:
1819 ch = Ctrl('q');
1820 s = &ch;
1821 n = 1;
1822 LayProcess(&s, &n);
1823 break;
1824 case RC_XOFF:
1825 ch = Ctrl('s');
1826 s = &ch;
1827 n = 1;
1828 LayProcess(&s, &n);
1829 break;
1830 case RC_DEFBREAKTYPE:
1831 case RC_BREAKTYPE:
1832 {
1833 static char *types[] = { "TIOCSBRK", "TCSBRK", "tcsendbreak", NULL };
1834 extern int breaktype;
1835
1836 if (*args)
1837 {
1838 if (ParseNum(act, &n))
1839 for (n = 0; n < (int)(sizeof(types)/sizeof(*types)); n++)
1840 {
1841 for (i = 0; i < 4; i++)
1842 {
1843 ch = args[0][i];
1844 if (ch >= 'a' && ch <= 'z')
1845 ch -= 'a' - 'A';
1846 if (ch != types[n][i] && (ch + ('a' - 'A')) != types[n][i])
1847 break;
1848 }
1849 if (i == 4)
1850 break;
1851 }
1852 if (n < 0 || n >= (int)(sizeof(types)/sizeof(*types)))
1853 Msg(0, "%s invalid, chose one of %s, %s or %s", *args, types[0], types[1], types[2]);
1854 else
1855 {
1856 breaktype = n;
1857 Msg(0, "breaktype set to (%d) %s", n, types[n]);
1858 }
1859 }
1860 else
1861 Msg(0, "breaktype is (%d) %s", breaktype, types[breaktype]);
1862 }
1863 break;
1864 case RC_POW_BREAK:
1865 case RC_BREAK:
1866 n = 0;
1867 if (*args && ParseNum(act, &n))
1868 break;
1869 SendBreak(fore, n, nr == RC_POW_BREAK);
1870 break;
1871 #ifdef LOCK
1872 case RC_LOCKSCREEN:
1873 Detach(D_LOCK);
1874 break;
1875 #endif
1876 case RC_WIDTH:
1877 case RC_HEIGHT:
1878 {
1879 int w, h;
1880 int what = 0;
1881
1882 i = 1;
1883 if (*args && !strcmp(*args, "-w"))
1884 what = 1;
1885 else if (*args && !strcmp(*args, "-d"))
1886 what = 2;
1887 if (what)
1888 args++;
1889 if (what == 0 && flayer && !display)
1890 what = 1;
1891 if (what == 1)
1892 {
1893 if (!flayer)
1894 {
1895 Msg(0, "%s: %s: window required", rc_name, comms[nr].name);
1896 break;
1897 }
1898 w = flayer->l_width;
1899 h = flayer->l_height;
1900 }
1901 else
1902 {
1903 if (!display)
1904 {
1905 Msg(0, "%s: %s: display required", rc_name, comms[nr].name);
1906 break;
1907 }
1908 w = D_width;
1909 h = D_height;
1910 }
1911 if (*args && args[0][0] == '-')
1912 {
1913 Msg(0, "%s: %s: unknown option %s", rc_name, comms[nr].name, *args);
1914 break;
1915 }
1916 if (nr == RC_HEIGHT)
1917 {
1918 if (!*args)
1919 {
1920 #define H0height 42
1921 #define H1height 24
1922 if (h == H0height)
1923 h = H1height;
1924 else if (h == H1height)
1925 h = H0height;
1926 else if (h > (H0height + H1height) / 2)
1927 h = H0height;
1928 else
1929 h = H1height;
1930 }
1931 else
1932 {
1933 h = atoi(*args);
1934 if (args[1])
1935 w = atoi(args[1]);
1936 }
1937 }
1938 else
1939 {
1940 if (!*args)
1941 {
1942 if (w == Z0width)
1943 w = Z1width;
1944 else if (w == Z1width)
1945 w = Z0width;
1946 else if (w > (Z0width + Z1width) / 2)
1947 w = Z0width;
1948 else
1949 w = Z1width;
1950 }
1951 else
1952 {
1953 w = atoi(*args);
1954 if (args[1])
1955 h = atoi(args[1]);
1956 }
1957 }
1958 if (*args && args[1] && args[2])
1959 {
1960 Msg(0, "%s: %s: too many arguments", rc_name, comms[nr].name);
1961 break;
1962 }
1963 if (w <= 0)
1964 {
1965 Msg(0, "Illegal width");
1966 break;
1967 }
1968 if (h <= 0)
1969 {
1970 Msg(0, "Illegal height");
1971 break;
1972 }
1973 if (what == 1)
1974 {
1975 if (flayer->l_width == w && flayer->l_height == h)
1976 break;
1977 ResizeLayer(flayer, w, h, (struct display *)0);
1978 break;
1979 }
1980 if (D_width == w && D_height == h)
1981 break;
1982 if (what == 2)
1983 {
1984 ChangeScreenSize(w, h, 1);
1985 }
1986 else
1987 {
1988 if (ResizeDisplay(w, h) == 0)
1989 {
1990 Activate(D_fore ? D_fore->w_norefresh : 0);
1991 /* autofit */
1992 ResizeLayer(D_forecv->c_layer, D_forecv->c_xe - D_forecv->c_xs + 1, D_forecv->c_ye - D_forecv->c_ys + 1, 0);
1993 break;
1994 }
1995 if (h == D_height)
1996 Msg(0, "Your termcap does not specify how to change the terminal's width to %d.", w);
1997 else if (w == D_width)
1998 Msg(0, "Your termcap does not specify how to change the terminal's height to %d.", h);
1999 else
2000 Msg(0, "Your termcap does not specify how to change the terminal's resolution to %dx%d.", w, h);
2001 }
2002 }
2003 break;
2004 case RC_TITLE:
2005 if (*args == 0)
2006 InputAKA();
2007 else
2008 ChangeAKA(fore, *args, strlen(*args));
2009 break;
2010 case RC_COLON:
2011 Input(":", 100, INP_EVERY, Colonfin, NULL, 0);
2012 if (*args && **args)
2013 {
2014 s = *args;
2015 n = strlen(s);
2016 LayProcess(&s, &n);
2017 }
2018 break;
2019 case RC_LASTMSG:
2020 if (D_status_lastmsg)
2021 Msg(0, "%s", D_status_lastmsg);
2022 break;
2023 case RC_SCREEN:
2024 DoScreen("key", args);
2025 break;
2026 case RC_WRAP:
2027 if (ParseSwitch(act, &fore->w_wrap) == 0 && msgok)
2028 Msg(0, "%cwrap", fore->w_wrap ? '+' : '-');
2029 break;
2030 case RC_FLOW:
2031 if (*args)
2032 {
2033 if (args[0][0] == 'a')
2034 {
2035 fore->w_flow = (fore->w_flow & FLOW_AUTO) ? FLOW_AUTOFLAG |FLOW_AUTO|FLOW_NOW : FLOW_AUTOFLAG;
2036 }
2037 else
2038 {
2039 if (ParseOnOff(act, &n))
2040 break;
2041 fore->w_flow = (fore->w_flow & FLOW_AUTO) | n;
2042 }
2043 }
2044 else
2045 {
2046 if (fore->w_flow & FLOW_AUTOFLAG)
2047 fore->w_flow = (fore->w_flow & FLOW_AUTO) | FLOW_NOW;
2048 else if (fore->w_flow & FLOW_NOW)
2049 fore->w_flow &= ~FLOW_NOW;
2050 else
2051 fore->w_flow = fore->w_flow ? FLOW_AUTOFLAG|FLOW_AUTO|FLOW_NOW : FLOW_AUTOFLAG;
2052 }
2053 SetFlow(fore->w_flow & FLOW_NOW);
2054 if (msgok)
2055 Msg(0, "%cflow%s", (fore->w_flow & FLOW_NOW) ? '+' : '-',
2056 (fore->w_flow & FLOW_AUTOFLAG) ? "(auto)" : "");
2057 break;
2058 #ifdef MULTIUSER
2059 case RC_DEFWRITELOCK:
2060 if (args[0][0] == 'a')
2061 nwin_default.wlock = WLOCK_AUTO;
2062 else
2063 {
2064 if (ParseOnOff(act, &n))
2065 break;
2066 nwin_default.wlock = n ? WLOCK_ON : WLOCK_OFF;
2067 }
2068 break;
2069 case RC_WRITELOCK:
2070 if (*args)
2071 {
2072 if (args[0][0] == 'a')
2073 {
2074 fore->w_wlock = WLOCK_AUTO;
2075 }
2076 else
2077 {
2078 if (ParseOnOff(act, &n))
2079 break;
2080 fore->w_wlock = n ? WLOCK_ON : WLOCK_OFF;
2081 }
2082 /*
2083 * user may have permission to change the writelock setting,
2084 * but he may never aquire the lock himself without write permission
2085 */
2086 if (!AclCheckPermWin(D_user, ACL_WRITE, fore))
2087 fore->w_wlockuser = D_user;
2088 }
2089 Msg(0, "writelock %s", (fore->w_wlock == WLOCK_AUTO) ? "auto" :
2090 ((fore->w_wlock == WLOCK_OFF) ? "off" : "on"));
2091 break;
2092 #endif
2093 case RC_CLEAR:
2094 ResetAnsiState(fore);
2095 WriteString(fore, "\033[H\033[J", 6);
2096 break;
2097 case RC_RESET:
2098 ResetAnsiState(fore);
2099 #ifdef ZMODEM
2100 if (fore->w_zdisplay)
2101 zmodem_abort(fore, fore->w_zdisplay);
2102 #endif
2103 WriteString(fore, "\033c", 2);
2104 break;
2105 case RC_MONITOR:
2106 n = fore->w_monitor != MON_OFF;
2107 #ifdef MULTIUSER
2108 if (display)
2109 n = n && (ACLBYTE(fore->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id));
2110 #endif
2111 if (ParseSwitch(act, &n))
2112 break;
2113 if (n)
2114 {
2115 #ifdef MULTIUSER
2116 if (display) /* we tell only this user */
2117 ACLBYTE(fore->w_mon_notify, D_user->u_id) |= ACLBIT(D_user->u_id);
2118 else
2119 for (i = 0; i < maxusercount; i++)
2120 ACLBYTE(fore->w_mon_notify, i) |= ACLBIT(i);
2121 #endif
2122 if (fore->w_monitor == MON_OFF)
2123 fore->w_monitor = MON_ON;
2124 Msg(0, "Window %d (%s) is now being monitored for all activity.", fore->w_number, fore->w_title);
2125 }
2126 else
2127 {
2128 #ifdef MULTIUSER
2129 if (display) /* we remove only this user */
2130 ACLBYTE(fore->w_mon_notify, D_user->u_id)
2131 &= ~ACLBIT(D_user->u_id);
2132 else
2133 for (i = 0; i < maxusercount; i++)
2134 ACLBYTE(fore->w_mon_notify, i) &= ~ACLBIT(i);
2135 for (i = maxusercount - 1; i >= 0; i--)
2136 if (ACLBYTE(fore->w_mon_notify, i))
2137 break;
2138 if (i < 0)
2139 #endif
2140 fore->w_monitor = MON_OFF;
2141 Msg(0, "Window %d (%s) is no longer being monitored for activity.", fore->w_number, fore->w_title);
2142 }
2143 break;
2144 #ifdef MULTI
2145 case RC_DISPLAYS:
2146 display_displays();
2147 break;
2148 #endif
2149 case RC_WINDOWLIST:
2150 if (!*args)
2151 display_wlist(0, WLIST_NUM, (struct win *)0);
2152 else if (!strcmp(*args, "string"))
2153 {
2154 if (args[1])
2155 {
2156 if (wliststr)
2157 free(wliststr);
2158 wliststr = SaveStr(args[1]);
2159 }
2160 if (msgok)
2161 Msg(0, "windowlist string is '%s'", wliststr);
2162 }
2163 else if (!strcmp(*args, "title"))
2164 {
2165 if (args[1])
2166 {
2167 if (wlisttit)
2168 free(wlisttit);
2169 wlisttit = SaveStr(args[1]);
2170 }
2171 if (msgok)
2172 Msg(0, "windowlist title is '%s'", wlisttit);
2173 }
2174 else
2175 {
2176 int flag = 0;
2177 int blank = 0;
2178 for (i = 0; i < argc; i++)
2179 if (!args[i])
2180 continue;
2181 else if (!strcmp(args[i], "-m"))
2182 flag |= WLIST_MRU;
2183 else if (!strcmp(args[i], "-b"))
2184 blank = 1;
2185 else if (!strcmp(args[i], "-g"))
2186 flag |= WLIST_NESTED;
2187 else
2188 {
2189 Msg(0, "usage: windowlist [-b] [-g] [-m] [string [string] | title [title]]");
2190 break;
2191 }
2192 if (i == argc)
2193 display_wlist(blank, flag, (struct win *)0);
2194 }
2195 break;
2196 case RC_HELP:
2197 if (argc == 2 && !strcmp(*args, "-c"))
2198 {
2199 struct action *ktabp;
2200 if ((ktabp = FindKtab(args[1], 0)) == 0)
2201 {
2202 Msg(0, "Unknown command class '%s'", args[1]);
2203 break;
2204 }
2205 display_help(args[1], ktabp);
2206 }
2207 else
2208 display_help((char *)0, ktab);
2209 break;
2210 case RC_LICENSE:
2211 display_copyright();
2212 break;
2213 #ifdef COPY_PASTE
2214 case RC_COPY:
2215 if (flayer->l_layfn != &WinLf)
2216 {
2217 Msg(0, "Must be on a window layer");
2218 break;
2219 }
2220 MarkRoutine();
2221 break;
2222 case RC_HISTORY:
2223 {
2224 static char *pasteargs[] = {".", 0};
2225 static int pasteargl[] = {1};
2226
2227 if (flayer->l_layfn != &WinLf)
2228 {
2229 Msg(0, "Must be on a window layer");
2230 break;
2231 }
2232 if (GetHistory() == 0)
2233 break;
2234 if (user->u_plop.buf == NULL)
2235 break;
2236 args = pasteargs;
2237 argl = pasteargl;
2238 }
2239 /*FALLTHROUGH*/
2240 case RC_PASTE:
2241 {
2242 char *ss, *dbuf, dch;
2243 int l = 0;
2244 # ifdef ENCODINGS
2245 int enc = -1;
2246 # endif
2247
2248 /*
2249 * without args we prompt for one(!) register to be pasted in the window
2250 */
2251 if ((s = *args) == NULL)
2252 {
2253 Input("Paste from register:", 1, INP_RAW, ins_reg_fn, NULL, 0);
2254 break;
2255 }
2256 if (args[1] == 0 && !fore) /* no window? */
2257 break;
2258 /*
2259 * with two arguments we paste into a destination register
2260 * (no window needed here).
2261 */
2262 if (args[1] && argl[1] != 1)
2263 {
2264 Msg(0, "%s: paste destination: character, ^x, or (octal) \\032 expected.",
2265 rc_name);
2266 break;
2267 }
2268 # ifdef ENCODINGS
2269 else if (fore)
2270 enc = fore->w_encoding;
2271 # endif
2272
2273 /*
2274 * measure length of needed buffer
2275 */
2276 for (ss = s = *args; (ch = *ss); ss++)
2277 {
2278 if (ch == '.')
2279 {
2280 # ifdef ENCODINGS
2281 if (enc == -1)
2282 enc = user->u_plop.enc;
2283 if (enc != user->u_plop.enc)
2284 l += RecodeBuf((unsigned char *)user->u_plop.buf, user->u_plop.len, user->u_plop.enc, enc, (unsigned char *)0);
2285 else
2286 # endif
2287 l += user->u_plop.len;
2288 }
2289 else
2290 {
2291 # ifdef ENCODINGS
2292 if (enc == -1)
2293 enc = plop_tab[(int)(unsigned char)ch].enc;
2294 if (enc != plop_tab[(int)(unsigned char)ch].enc)
2295 l += RecodeBuf((unsigned char *)plop_tab[(int)(unsigned char)ch].buf, plop_tab[(int)(unsigned char)ch].len, plop_tab[(int)(unsigned char)ch].enc, enc, (unsigned char *)0);
2296 else
2297 # endif
2298 l += plop_tab[(int)(unsigned char)ch].len;
2299 }
2300 }
2301 if (l == 0)
2302 {
2303 Msg(0, "empty buffer");
2304 break;
2305 }
2306 /*
2307 * shortcut:
2308 * if there is only one source and the destination is a window, then
2309 * pass a pointer rather than duplicating the buffer.
2310 */
2311 if (s[1] == 0 && args[1] == 0)
2312 # ifdef ENCODINGS
2313 if (enc == (*s == '.' ? user->u_plop.enc : plop_tab[(int)(unsigned char)*s].enc))
2314 # endif
2315 {
2316 MakePaster(&fore->w_paster, *s == '.' ? user->u_plop.buf : plop_tab[(int)(unsigned char)*s].buf, l, 0);
2317 break;
2318 }
2319 /*
2320 * if no shortcut, we construct a buffer
2321 */
2322 if ((dbuf = (char *)malloc(l)) == 0)
2323 {
2324 Msg(0, strnomem);
2325 break;
2326 }
2327 l = 0;
2328 /*
2329 * concatenate all sources into our own buffer, copy buffer is
2330 * special and is skipped if no display exists.
2331 */
2332 for (ss = s; (ch = *ss); ss++)
2333 {
2334 struct plop *pp = (ch == '.' ? &user->u_plop : &plop_tab[(int)(unsigned char)ch]);
2335 #ifdef ENCODINGS
2336 if (pp->enc != enc)
2337 {
2338 l += RecodeBuf((unsigned char *)pp->buf, pp->len, pp->enc, enc, (unsigned char *)dbuf + l);
2339 continue;
2340 }
2341 #endif
2342 bcopy(pp->buf, dbuf + l, pp->len);
2343 l += pp->len;
2344 }
2345 /*
2346 * when called with one argument we paste our buffer into the window
2347 */
2348 if (args[1] == 0)
2349 {
2350 MakePaster(&fore->w_paster, dbuf, l, 1);
2351 }
2352 else
2353 {
2354 /*
2355 * we have two arguments, the second is already in dch.
2356 * use this as destination rather than the window.
2357 */
2358 dch = args[1][0];
2359 if (dch == '.')
2360 {
2361 if (user->u_plop.buf != NULL)
2362 UserFreeCopyBuffer(user);
2363 user->u_plop.buf = dbuf;
2364 user->u_plop.len = l;
2365 #ifdef ENCODINGS
2366 user->u_plop.enc = enc;
2367 #endif
2368 }
2369 else
2370 {
2371 struct plop *pp = plop_tab + (int)(unsigned char)dch;
2372 if (pp->buf)
2373 free(pp->buf);
2374 pp->buf = dbuf;
2375 pp->len = l;
2376 #ifdef ENCODINGS
2377 pp->enc = enc;
2378 #endif
2379 }
2380 }
2381 break;
2382 }
2383 case RC_WRITEBUF:
2384 if (!user->u_plop.buf)
2385 {
2386 Msg(0, "empty buffer");
2387 break;
2388 }
2389 #ifdef ENCODINGS
2390 {
2391 struct plop oldplop;
2392
2393 oldplop = user->u_plop;
2394 if (args[0] && args[1] && !strcmp(args[0], "-e"))
2395 {
2396 int enc, l;
2397 char *newbuf;
2398
2399 enc = FindEncoding(args[1]);
2400 if (enc == -1)
2401 {
2402 Msg(0, "%s: writebuf: unknown encoding", rc_name);
2403 break;
2404 }
2405 if (enc != oldplop.enc)
2406 {
2407 l = RecodeBuf((unsigned char *)oldplop.buf, oldplop.len, oldplop.enc, enc, (unsigned char *)0);
2408 newbuf = malloc(l + 1);
2409 if (!newbuf)
2410 {
2411 Msg(0, strnomem);
2412 break;
2413 }
2414 user->u_plop.len = RecodeBuf((unsigned char *)oldplop.buf, oldplop.len, oldplop.enc, enc, (unsigned char *)newbuf);
2415 user->u_plop.buf = newbuf;
2416 user->u_plop.enc = enc;
2417 }
2418 args += 2;
2419 }
2420 #endif
2421 if (args[0] && args[1])
2422 Msg(0, "%s: writebuf: too many arguments", rc_name);
2423 else
2424 WriteFile(user, args[0], DUMP_EXCHANGE);
2425 #ifdef ENCODINGS
2426 if (user->u_plop.buf != oldplop.buf)
2427 free(user->u_plop.buf);
2428 user->u_plop = oldplop;
2429 }
2430 #endif
2431 break;
2432 case RC_READBUF:
2433 #ifdef ENCODINGS
2434 i = fore ? fore->w_encoding : display ? display->d_encoding : 0;
2435 if (args[0] && args[1] && !strcmp(args[0], "-e"))
2436 {
2437 i = FindEncoding(args[1]);
2438 if (i == -1)
2439 {
2440 Msg(0, "%s: readbuf: unknown encoding", rc_name);
2441 break;
2442 }
2443 args += 2;
2444 }
2445 #endif
2446 if (args[0] && args[1])
2447 {
2448 Msg(0, "%s: readbuf: too many arguments", rc_name);
2449 break;
2450 }
2451 if ((s = ReadFile(args[0] ? args[0] : BufferFile, &n)))
2452 {
2453 if (user->u_plop.buf)
2454 UserFreeCopyBuffer(user);
2455 user->u_plop.len = n;
2456 user->u_plop.buf = s;
2457 #ifdef ENCODINGS
2458 user->u_plop.enc = i;
2459 #endif
2460 }
2461 break;
2462 case RC_REMOVEBUF:
2463 KillBuffers();
2464 break;
2465 case RC_IGNORECASE:
2466 (void)ParseSwitch(act, &search_ic);
2467 if (msgok)
2468 Msg(0, "Will %signore case in searches", search_ic ? "" : "not ");
2469 break;
2470 #endif /* COPY_PASTE */
2471 case RC_ESCAPE:
2472 if (*argl == 0)
2473 SetEscape(user, -1, -1);
2474 else if (*argl == 2)
2475 SetEscape(user, (int)(unsigned char)args[0][0], (int)(unsigned char)args[0][1]);
2476 else
2477 {
2478 Msg(0, "%s: two characters required after escape.", rc_name);
2479 break;
2480 }
2481 /* Change defescape if master user. This is because we only
2482 * have one ktab.
2483 */
2484 if (display && user != users)
2485 break;
2486 /* FALLTHROUGH */
2487 case RC_DEFESCAPE:
2488 if (*argl == 0)
2489 SetEscape(NULL, -1, -1);
2490 else if (*argl == 2)
2491 SetEscape(NULL, (int)(unsigned char)args[0][0], (int)(unsigned char)args[0][1]);
2492 else
2493 {
2494 Msg(0, "%s: two characters required after defescape.", rc_name);
2495 break;
2496 }
2497 #ifdef MAPKEYS
2498 CheckEscape();
2499 #endif
2500 break;
2501 case RC_CHDIR:
2502 s = *args ? *args : home;
2503 if (chdir(s) == -1)
2504 Msg(errno, "%s", s);
2505 break;
2506 case RC_SHELL:
2507 case RC_DEFSHELL:
2508 if (ParseSaveStr(act, &ShellProg) == 0)
2509 ShellArgs[0] = ShellProg;
2510 break;
2511 case RC_HARDCOPYDIR:
2512 if (*args)
2513 (void)ParseSaveStr(act, &hardcopydir);
2514 if (msgok)
2515 Msg(0, "hardcopydir is %s\n", hardcopydir && *hardcopydir ? hardcopydir : "<cwd>");
2516 break;
2517 case RC_LOGFILE:
2518 if (*args)
2519 {
2520 if (args[1] && !(strcmp(*args, "flush")))
2521 {
2522 log_flush = atoi(args[1]);
2523 if (msgok)
2524 Msg(0, "log flush timeout set to %ds\n", log_flush);
2525 break;
2526 }
2527 if (ParseSaveStr(act, &screenlogfile) || !msgok)
2528 break;
2529 }
2530 Msg(0, "logfile is '%s'", screenlogfile);
2531 break;
2532 case RC_LOGTSTAMP:
2533 if (!*args || !strcmp(*args, "on") || !strcmp(*args, "off"))
2534 {
2535 if (ParseSwitch(act, &logtstamp_on) == 0 && msgok)
2536 Msg(0, "timestamps turned %s", logtstamp_on ? "on" : "off");
2537 }
2538 else if (!strcmp(*args, "string"))
2539 {
2540 if (args[1])
2541 {
2542 if (logtstamp_string)
2543 free(logtstamp_string);
2544 logtstamp_string = SaveStr(args[1]);
2545 }
2546 if (msgok)
2547 Msg(0, "logfile timestamp is '%s'", logtstamp_string);
2548 }
2549 else if (!strcmp(*args, "after"))
2550 {
2551 if (args[1])
2552 {
2553 logtstamp_after = atoi(args[1]);
2554 if (!msgok)
2555 break;
2556 }
2557 Msg(0, "timestamp printed after %ds\n", logtstamp_after);
2558 }
2559 else
2560 Msg(0, "usage: logtstamp [after [n]|string [str]|on|off]");
2561 break;
2562 case RC_SHELLTITLE:
2563 (void)ParseSaveStr(act, &nwin_default.aka);
2564 break;
2565 case RC_TERMCAP:
2566 case RC_TERMCAPINFO:
2567 case RC_TERMINFO:
2568 if (!rc_name || !*rc_name)
2569 Msg(0, "Sorry, too late now. Place that in your .screenrc file.");
2570 break;
2571 case RC_SLEEP:
2572 break; /* Already handled */
2573 case RC_TERM:
2574 s = NULL;
2575 if (ParseSaveStr(act, &s))
2576 break;
2577 if (strlen(s) >= 20)
2578 {
2579 Msg(0, "%s: term: argument too long ( < 20)", rc_name);
2580 free(s);
2581 break;
2582 }
2583 strcpy(screenterm, s);
2584 free(s);
2585 debug1("screenterm set to %s\n", screenterm);
2586 MakeTermcap((display == 0));
2587 debug("new termcap made\n");
2588 break;
2589 case RC_ECHO:
2590 if (!msgok && (!rc_name || strcmp(rc_name, "-X")))
2591 break;
2592 /*
2593 * user typed ^A:echo... well, echo isn't FinishRc's job,
2594 * but as he wanted to test us, we show good will
2595 */
2596 if (argc > 1 && !strcmp(*args, "-n"))
2597 {
2598 args++;
2599 argc--;
2600 }
2601 s = *args;
2602 if (argc > 1 && !strcmp(*args, "-p"))
2603 {
2604 args++;
2605 argc--;
2606 s = *args;
2607 if (s)
2608 s = MakeWinMsg(s, fore, '%');
2609 }
2610 if (s)
2611 Msg(0, "%s", s);
2612 else
2613 Msg(0, "%s: 'echo [-n] [-p] \"string\"' expected.", rc_name);
2614 break;
2615 case RC_BELL:
2616 case RC_BELL_MSG:
2617 if (*args == 0)
2618 {
2619 char buf[256];
2620 AddXChars(buf, sizeof(buf), BellString);
2621 Msg(0, "bell_msg is '%s'", buf);
2622 break;
2623 }
2624 (void)ParseSaveStr(act, &BellString);
2625 break;
2626 #ifdef COPY_PASTE
2627 case RC_BUFFERFILE:
2628 if (*args == 0)
2629 BufferFile = SaveStr(DEFAULT_BUFFERFILE);
2630 else if (ParseSaveStr(act, &BufferFile))
2631 break;
2632 if (msgok)
2633 Msg(0, "Bufferfile is now '%s'", BufferFile);
2634 break;
2635 #endif
2636 case RC_ACTIVITY:
2637 (void)ParseSaveStr(act, &ActivityString);
2638 break;
2639 #if defined(DETACH) && defined(POW_DETACH)
2640 case RC_POW_DETACH_MSG:
2641 if (*args == 0)
2642 {
2643 char buf[256];
2644 AddXChars(buf, sizeof(buf), PowDetachString);
2645 Msg(0, "pow_detach_msg is '%s'", buf);
2646 break;
2647 }
2648 (void)ParseSaveStr(act, &PowDetachString);
2649 break;
2650 #endif
2651 #if defined(UTMPOK) && defined(LOGOUTOK)
2652 case RC_LOGIN:
2653 n = fore->w_slot != (slot_t)-1;
2654 if (*args && !strcmp(*args, "always"))
2655 {
2656 fore->w_lflag = 3;
2657 if (!displays && n)
2658 SlotToggle(n);
2659 break;
2660 }
2661 if (*args && !strcmp(*args, "attached"))
2662 {
2663 fore->w_lflag = 1;
2664 if (!displays && n)
2665 SlotToggle(0);
2666 break;
2667 }
2668 if (ParseSwitch(act, &n) == 0)
2669 SlotToggle(n);
2670 break;
2671 case RC_DEFLOGIN:
2672 if (!strcmp(*args, "always"))
2673 nwin_default.lflag |= 2;
2674 else if (!strcmp(*args, "attached"))
2675 nwin_default.lflag &= ~2;
2676 else
2677 (void)ParseOnOff(act, &nwin_default.lflag);
2678 break;
2679 #endif
2680 case RC_DEFFLOW:
2681 if (args[0] && args[1] && args[1][0] == 'i')
2682 {
2683 iflag = 1;
2684 for (display = displays; display; display = display->d_next)
2685 {
2686 if (!D_flow)
2687 continue;
2688 #if defined(TERMIO) || defined(POSIX)
2689 D_NewMode.tio.c_cc[VINTR] = D_OldMode.tio.c_cc[VINTR];
2690 D_NewMode.tio.c_lflag |= ISIG;
2691 #else /* TERMIO || POSIX */
2692 D_NewMode.m_tchars.t_intrc = D_OldMode.m_tchars.t_intrc;
2693 #endif /* TERMIO || POSIX */
2694 SetTTY(D_userfd, &D_NewMode);
2695 }
2696 }
2697 if (args[0] && args[0][0] == 'a')
2698 nwin_default.flowflag = FLOW_AUTOFLAG;
2699 else
2700 (void)ParseOnOff(act, &nwin_default.flowflag);
2701 break;
2702 case RC_DEFWRAP:
2703 (void)ParseOnOff(act, &nwin_default.wrap);
2704 break;
2705 case RC_DEFC1:
2706 (void)ParseOnOff(act, &nwin_default.c1);
2707 break;
2708 #ifdef COLOR
2709 case RC_DEFBCE:
2710 (void)ParseOnOff(act, &nwin_default.bce);
2711 break;
2712 #endif
2713 case RC_DEFGR:
2714 (void)ParseOnOff(act, &nwin_default.gr);
2715 break;
2716 case RC_DEFMONITOR:
2717 if (ParseOnOff(act, &n) == 0)
2718 nwin_default.monitor = (n == 0) ? MON_OFF : MON_ON;
2719 break;
2720 case RC_DEFSILENCE:
2721 if (ParseOnOff(act, &n) == 0)
2722 nwin_default.silence = (n == 0) ? SILENCE_OFF : SILENCE_ON;
2723 break;
2724 case RC_VERBOSE:
2725 if (!*args)
2726 Msg(0, "W%s echo command when creating windows.",
2727 VerboseCreate ? "ill" : "on't");
2728 else if (ParseOnOff(act, &n) == 0)
2729 VerboseCreate = n;
2730 break;
2731 case RC_HARDSTATUS:
2732 if (display)
2733 {
2734 Msg(0, "%s", ""); /* wait till mintime (keep gcc quiet) */
2735 RemoveStatus();
2736 }
2737 if (args[0] && strcmp(args[0], "on") && strcmp(args[0], "off"))
2738 {
2739 struct display *olddisplay = display;
2740 int old_use, new_use = -1;
2741
2742 s = args[0];
2743 if (!strncmp(s, "always", 6))
2744 s += 6;
2745 if (!strcmp(s, "lastline"))
2746 new_use = HSTATUS_LASTLINE;
2747 else if (!strcmp(s, "ignore"))
2748 new_use = HSTATUS_IGNORE;
2749 else if (!strcmp(s, "message"))
2750 new_use = HSTATUS_MESSAGE;
2751 else if (!strcmp(args[0], "string"))
2752 {
2753 if (!args[1])
2754 {
2755 char buf[256];
2756 AddXChars(buf, sizeof(buf), hstatusstring);
2757 Msg(0, "hardstatus string is '%s'", buf);
2758 break;
2759 }
2760 }
2761 else
2762 {
2763 Msg(0, "%s: usage: hardstatus [always]lastline|ignore|message|string [string]", rc_name);
2764 break;
2765 }
2766 if (new_use != -1)
2767 {
2768 hardstatusemu = new_use | (s == args[0] ? 0 : HSTATUS_ALWAYS);
2769 for (display = displays; display; display = display->d_next)
2770 {
2771 RemoveStatus();
2772 new_use = hardstatusemu & ~HSTATUS_ALWAYS;
2773 if (D_HS && s == args[0])
2774 new_use = HSTATUS_HS;
2775 ShowHStatus((char *)0);
2776 old_use = D_has_hstatus;
2777 D_has_hstatus = new_use;
2778 if ((new_use == HSTATUS_LASTLINE && old_use != HSTATUS_LASTLINE) || (new_use != HSTATUS_LASTLINE && old_use == HSTATUS_LASTLINE))
2779 ChangeScreenSize(D_width, D_height, 1);
2780 RefreshHStatus();
2781 }
2782 }
2783 if (args[1])
2784 {
2785 if (hstatusstring)
2786 free(hstatusstring);
2787 hstatusstring = SaveStr(args[1]);
2788 for (display = displays; display; display = display->d_next)
2789 RefreshHStatus();
2790 }
2791 display = olddisplay;
2792 break;
2793 }
2794 (void)ParseSwitch(act, &use_hardstatus);
2795 if (msgok)
2796 Msg(0, "messages displayed on %s", use_hardstatus ? "hardstatus line" : "window");
2797 break;
2798 case RC_CAPTION:
2799 if (strcmp(args[0], "always") == 0 || strcmp(args[0], "splitonly") == 0)
2800 {
2801 struct display *olddisplay = display;
2802
2803 captionalways = args[0][0] == 'a';
2804 for (display = displays; display; display = display->d_next)
2805 ChangeScreenSize(D_width, D_height, 1);
2806 display = olddisplay;
2807 }
2808 else if (strcmp(args[0], "string") == 0)
2809 {
2810 if (!args[1])
2811 {
2812 char buf[256];
2813 AddXChars(buf, sizeof(buf), captionstring);
2814 Msg(0, "caption string is '%s'", buf);
2815 break;
2816 }
2817 }
2818 else
2819 {
2820 Msg(0, "%s: usage: caption always|splitonly|string <string>", rc_name);
2821 break;
2822 }
2823 if (!args[1])
2824 break;
2825 if (captionstring)
2826 free(captionstring);
2827 captionstring = SaveStr(args[1]);
2828 RedisplayDisplays(0);
2829 break;
2830 case RC_CONSOLE:
2831 n = (console_window != 0);
2832 if (ParseSwitch(act, &n))
2833 break;
2834 if (TtyGrabConsole(fore->w_ptyfd, n, rc_name))
2835 break;
2836 if (n == 0)
2837 Msg(0, "%s: releasing console %s", rc_name, HostName);
2838 else if (console_window)
2839 Msg(0, "%s: stealing console %s from window %d (%s)", rc_name,
2840 HostName, console_window->w_number, console_window->w_title);
2841 else
2842 Msg(0, "%s: grabbing console %s", rc_name, HostName);
2843 console_window = n ? fore : 0;
2844 break;
2845 case RC_ALLPARTIAL:
2846 if (ParseOnOff(act, &all_norefresh))
2847 break;
2848 if (!all_norefresh && fore)
2849 Activate(-1);
2850 if (msgok)
2851 Msg(0, all_norefresh ? "No refresh on window change!\n" :
2852 "Window specific refresh\n");
2853 break;
2854 case RC_PARTIAL:
2855 (void)ParseSwitch(act, &n);
2856 fore->w_norefresh = n;
2857 break;
2858 case RC_VBELL:
2859 if (ParseSwitch(act, &visual_bell) || !msgok)
2860 break;
2861 if (visual_bell == 0)
2862 Msg(0, "switched to audible bell.");
2863 else
2864 Msg(0, "switched to visual bell.");
2865 break;
2866 case RC_VBELLWAIT:
2867 if (ParseNum1000(act, &VBellWait) == 0 && msgok)
2868 Msg(0, "vbellwait set to %.10g seconds", VBellWait/1000.);
2869 break;
2870 case RC_MSGWAIT:
2871 if (ParseNum1000(act, &MsgWait) == 0 && msgok)
2872 Msg(0, "msgwait set to %.10g seconds", MsgWait/1000.);
2873 break;
2874 case RC_MSGMINWAIT:
2875 if (ParseNum1000(act, &MsgMinWait) == 0 && msgok)
2876 Msg(0, "msgminwait set to %.10g seconds", MsgMinWait/1000.);
2877 break;
2878 case RC_SILENCEWAIT:
2879 if (ParseNum(act, &SilenceWait))
2880 break;
2881 if (SilenceWait < 1)
2882 SilenceWait = 1;
2883 for (p = windows; p; p = p->w_next)
2884 p->w_silencewait = SilenceWait;
2885 if (msgok)
2886 Msg(0, "silencewait set to %d seconds", SilenceWait);
2887 break;
2888 case RC_NUMBER:
2889 if (*args == 0)
2890 Msg(0, "This is window %d (%s).\n", fore->w_number, fore->w_title);
2891 else
2892 {
2893 int old = fore->w_number;
2894 int rel = 0, parse;
2895 if (args[0][0] == '+')
2896 rel = 1;
2897 else if (args[0][0] == '-')
2898 rel = -1;
2899 if (rel)
2900 ++act->args[0];
2901 parse = ParseNum(act, &n);
2902 if (rel)
2903 --act->args[0];
2904 if (parse)
2905 break;
2906 if (rel > 0)
2907 n += old;
2908 else if (rel < 0)
2909 n = old - n;
2910 if (n < 0 || n >= maxwin)
2911 {
2912 Msg(0, "Given window position is invalid.");
2913 return;
2914 }
2915 p = wtab[n];
2916 wtab[n] = fore;
2917 fore->w_number = n;
2918 wtab[old] = p;
2919 if (p)
2920 p->w_number = old;
2921 #ifdef MULTIUSER
2922 /* exchange the acls for these windows. */
2923 AclWinSwap(old, n);
2924 #endif
2925 #ifdef UTMPOK
2926 /* exchange the utmp-slots for these windows */
2927 if ((fore->w_slot != (slot_t) -1) && (fore->w_slot != (slot_t) 0))
2928 {
2929 RemoveUtmp(fore);
2930 SetUtmp(fore);
2931 }
2932 if (p && (p->w_slot != (slot_t) -1) && (p->w_slot != (slot_t) 0))
2933 {
2934 /* XXX: first display wins? */
2935 display = fore->w_layer.l_cvlist ? fore->w_layer.l_cvlist->c_display : 0;
2936 RemoveUtmp(p);
2937 SetUtmp(p);
2938 }
2939 #endif
2940
2941 WindowChanged(fore, 'n');
2942 WindowChanged((struct win *)0, 'w');
2943 WindowChanged((struct win *)0, 'W');
2944 WindowChanged((struct win *)0, 0);
2945 }
2946 break;
2947 case RC_SILENCE:
2948 n = fore->w_silence != 0;
2949 i = fore->w_silencewait;
2950 if (args[0] && (args[0][0] == '-' || (args[0][0] >= '0' && args[0][0] <= '9')))
2951 {
2952 if (ParseNum(act, &i))
2953 break;
2954 n = i > 0;
2955 }
2956 else if (ParseSwitch(act, &n))
2957 break;
2958 if (n)
2959 {
2960 #ifdef MULTIUSER
2961 if (display) /* we tell only this user */
2962 ACLBYTE(fore->w_lio_notify, D_user->u_id) |= ACLBIT(D_user->u_id);
2963 else
2964 for (n = 0; n < maxusercount; n++)
2965 ACLBYTE(fore->w_lio_notify, n) |= ACLBIT(n);
2966 #endif
2967 fore->w_silencewait = i;
2968 fore->w_silence = SILENCE_ON;
2969 SetTimeout(&fore->w_silenceev, fore->w_silencewait * 1000);
2970 evenq(&fore->w_silenceev);
2971
2972 if (!msgok)
2973 break;
2974 Msg(0, "The window is now being monitored for %d sec. silence.", fore->w_silencewait);
2975 }
2976 else
2977 {
2978 #ifdef MULTIUSER
2979 if (display) /* we remove only this user */
2980 ACLBYTE(fore->w_lio_notify, D_user->u_id)
2981 &= ~ACLBIT(D_user->u_id);
2982 else
2983 for (n = 0; n < maxusercount; n++)
2984 ACLBYTE(fore->w_lio_notify, n) &= ~ACLBIT(n);
2985 for (i = maxusercount - 1; i >= 0; i--)
2986 if (ACLBYTE(fore->w_lio_notify, i))
2987 break;
2988 if (i < 0)
2989 #endif
2990 {
2991 fore->w_silence = SILENCE_OFF;
2992 evdeq(&fore->w_silenceev);
2993 }
2994 if (!msgok)
2995 break;
2996 Msg(0, "The window is no longer being monitored for silence.");
2997 }
2998 break;
2999 #ifdef COPY_PASTE
3000 case RC_DEFSCROLLBACK:
3001 (void)ParseNum(act, &nwin_default.histheight);
3002 break;
3003 case RC_SCROLLBACK:
3004 if (flayer->l_layfn == &MarkLf)
3005 {
3006 Msg(0, "Cannot resize scrollback buffer in copy/scrollback mode.");
3007 break;
3008 }
3009 (void)ParseNum(act, &n);
3010 ChangeWindowSize(fore, fore->w_width, fore->w_height, n);
3011 if (msgok)
3012 Msg(0, "scrollback set to %d", fore->w_histheight);
3013 break;
3014 #endif
3015 case RC_SESSIONNAME:
3016 if (*args == 0)
3017 Msg(0, "This session is named '%s'\n", SockName);
3018 else
3019 {
3020 char buf[MAXPATHLEN];
3021
3022 s = 0;
3023 if (ParseSaveStr(act, &s))
3024 break;
3025 if (!*s || strlen(s) + (SockName - SockPath) > MAXPATHLEN - 13 || index(s, '/'))
3026 {
3027 Msg(0, "%s: bad session name '%s'\n", rc_name, s);
3028 free(s);
3029 break;
3030 }
3031 strncpy(buf, SockPath, SockName - SockPath);
3032 sprintf(buf + (SockName - SockPath), "%d.%s", (int)getpid(), s);
3033 free(s);
3034 if ((access(buf, F_OK) == 0) || (errno != ENOENT))
3035 {
3036 Msg(0, "%s: inappropriate path: '%s'.", rc_name, buf);
3037 break;
3038 }
3039 if (rename(SockPath, buf))
3040 {
3041 Msg(errno, "%s: failed to rename(%s, %s)", rc_name, SockPath, buf);
3042 break;
3043 }
3044 debug2("rename(%s, %s) done\n", SockPath, buf);
3045 strcpy(SockPath, buf);
3046 MakeNewEnv();
3047 WindowChanged((struct win *)0, 'S');
3048 }
3049 break;
3050 case RC_SETENV:
3051 if (!args[0] || !args[1])
3052 {
3053 debug1("RC_SETENV arguments missing: %s\n", args[0] ? args[0] : "");
3054 InputSetenv(args[0]);
3055 }
3056 else
3057 {
3058 xsetenv(args[0], args[1]);
3059 MakeNewEnv();
3060 }
3061 break;
3062 case RC_UNSETENV:
3063 unsetenv(*args);
3064 MakeNewEnv();
3065 break;
3066 #ifdef COPY_PASTE
3067 case RC_DEFSLOWPASTE:
3068 (void)ParseNum(act, &nwin_default.slow);
3069 break;
3070 case RC_SLOWPASTE:
3071 if (*args == 0)
3072 Msg(0, fore->w_slowpaste ?
3073 "Slowpaste in window %d is %d milliseconds." :
3074 "Slowpaste in window %d is unset.",
3075 fore->w_number, fore->w_slowpaste);
3076 else if (ParseNum(act, &fore->w_slowpaste) == 0 && msgok)
3077 Msg(0, fore->w_slowpaste ?
3078 "Slowpaste in window %d set to %d milliseconds." :
3079 "Slowpaste in window %d now unset.",
3080 fore->w_number, fore->w_slowpaste);
3081 break;
3082 case RC_MARKKEYS:
3083 if (CompileKeys(*args, *argl, mark_key_tab))
3084 {
3085 Msg(0, "%s: markkeys: syntax error.", rc_name);
3086 break;
3087 }
3088 debug1("markkeys %s\n", *args);
3089 break;
3090 # ifdef FONT
3091 case RC_PASTEFONT:
3092 if (ParseSwitch(act, &pastefont) == 0 && msgok)
3093 Msg(0, "Will %spaste font settings", pastefont ? "" : "not ");
3094 break;
3095 # endif
3096 case RC_CRLF:
3097 (void)ParseSwitch(act, &join_with_cr);
3098 break;
3099 case RC_COMPACTHIST:
3100 if (ParseSwitch(act, &compacthist) == 0 && msgok)
3101 Msg(0, "%scompacting history lines", compacthist ? "" : "not ");
3102 break;
3103 #endif
3104 #ifdef NETHACK
3105 case RC_NETHACK:
3106 (void)ParseOnOff(act, &nethackflag);
3107 break;
3108 #endif
3109 case RC_HARDCOPY_APPEND:
3110 (void)ParseOnOff(act, &hardcopy_append);
3111 break;
3112 case RC_VBELL_MSG:
3113 if (*args == 0)
3114 {
3115 char buf[256];
3116 AddXChars(buf, sizeof(buf), VisualBellString);
3117 Msg(0, "vbell_msg is '%s'", buf);
3118 break;
3119 }
3120 (void)ParseSaveStr(act, &VisualBellString);
3121 debug1(" new vbellstr '%s'\n", VisualBellString);
3122 break;
3123 case RC_DEFMODE:
3124 if (ParseBase(act, *args, &n, 8, "octal"))
3125 break;
3126 if (n < 0 || n > 0777)
3127 {
3128 Msg(0, "%s: mode: Invalid tty mode %o", rc_name, n);
3129 break;
3130 }
3131 TtyMode = n;
3132 if (msgok)
3133 Msg(0, "Ttymode set to %03o", TtyMode);
3134 break;
3135 case RC_AUTODETACH:
3136 (void)ParseOnOff(act, &auto_detach);
3137 break;
3138 case RC_STARTUP_MESSAGE:
3139 (void)ParseOnOff(act, &default_startup);
3140 break;
3141 #ifdef PASSWORD
3142 case RC_PASSWORD:
3143 if (*args)
3144 {
3145 n = (*user->u_password) ? 1 : 0;
3146 if (user->u_password != NullStr) free((char *)user->u_password);
3147 user->u_password = SaveStr(*args);
3148 if (!strcmp(user->u_password, "none"))
3149 {
3150 if (n)
3151 Msg(0, "Password checking disabled");
3152 free(user->u_password);
3153 user->u_password = NullStr;
3154 }
3155 }
3156 else
3157 {
3158 if (!fore)
3159 {
3160 Msg(0, "%s: password: window required", rc_name);
3161 break;
3162 }
3163 Input("New screen password:", 100, INP_NOECHO, pass1, display ? (char *)D_user : (char *)users, 0);
3164 }
3165 break;
3166 #endif /* PASSWORD */
3167 case RC_BIND:
3168 {
3169 struct action *ktabp = ktab;
3170 int kflag = 0;
3171
3172 for (;;)
3173 {
3174 if (argc > 2 && !strcmp(*args, "-c"))
3175 {
3176 ktabp = FindKtab(args[1], 1);
3177 if (ktabp == 0)
3178 break;
3179 args += 2;
3180 argl += 2;
3181 argc -= 2;
3182 }
3183 else if (argc > 1 && !strcmp(*args, "-k"))
3184 {
3185 kflag = 1;
3186 args++;
3187 argl++;
3188 argc--;
3189 }
3190 else
3191 break;
3192 }
3193 #ifdef MAPKEYS
3194 if (kflag)
3195 {
3196 for (n = 0; n < KMAP_KEYS; n++)
3197 if (strcmp(term[n + T_CAPS].tcname, *args) == 0)
3198 break;
3199 if (n == KMAP_KEYS)
3200 {
3201 Msg(0, "%s: bind: unknown key '%s'", rc_name, *args);
3202 break;
3203 }
3204 n += 256;
3205 }
3206 else
3207 #endif
3208 if (*argl != 1)
3209 {
3210 Msg(0, "%s: bind: character, ^x, or (octal) \\032 expected.", rc_name);
3211 break;
3212 }
3213 else
3214 n = (unsigned char)args[0][0];
3215
3216 if (args[1])
3217 {
3218 if ((i = FindCommnr(args[1])) == RC_ILLEGAL)
3219 {
3220 Msg(0, "%s: bind: unknown command '%s'", rc_name, args[1]);
3221 break;
3222 }
3223 if (CheckArgNum(i, args + 2) < 0)
3224 break;
3225 ClearAction(&ktabp[n]);
3226 SaveAction(ktabp + n, i, args + 2, argl + 2);
3227 }
3228 else
3229 ClearAction(&ktabp[n]);
3230 }
3231 break;
3232 #ifdef MAPKEYS
3233 case RC_BINDKEY:
3234 {
3235 struct action *newact;
3236 int newnr, fl = 0, kf = 0, af = 0, df = 0, mf = 0;
3237 struct display *odisp = display;
3238 int used = 0;
3239 struct kmap_ext *kme;
3240
3241 for (; *args && **args == '-'; args++, argl++)
3242 {
3243 if (strcmp(*args, "-t") == 0)
3244 fl = KMAP_NOTIMEOUT;
3245 else if (strcmp(*args, "-k") == 0)
3246 kf = 1;
3247 else if (strcmp(*args, "-a") == 0)
3248 af = 1;
3249 else if (strcmp(*args, "-d") == 0)
3250 df = 1;
3251 else if (strcmp(*args, "-m") == 0)
3252 mf = 1;
3253 else if (strcmp(*args, "--") == 0)
3254 {
3255 args++;
3256 argl++;
3257 break;
3258 }
3259 else
3260 {
3261 Msg(0, "%s: bindkey: invalid option %s", rc_name, *args);
3262 return;
3263 }
3264 }
3265 if (df && mf)
3266 {
3267 Msg(0, "%s: bindkey: -d does not work with -m", rc_name);
3268 break;
3269 }
3270 if (*args == 0)
3271 {
3272 if (mf)
3273 display_bindkey("Edit mode", mmtab);
3274 else if (df)
3275 display_bindkey("Default", dmtab);
3276 else
3277 display_bindkey("User", umtab);
3278 break;
3279 }
3280 if (kf == 0)
3281 {
3282 if (af)
3283 {
3284 Msg(0, "%s: bindkey: -a only works with -k", rc_name);
3285 break;
3286 }
3287 if (*argl == 0)
3288 {
3289 Msg(0, "%s: bindkey: empty string makes no sense", rc_name);
3290 break;
3291 }
3292 for (i = 0, kme = kmap_exts; i < kmap_extn; i++, kme++)
3293 if (kme->str == 0)
3294 {
3295 if (args[1])
3296 break;
3297 }
3298 else
3299 if (*argl == (kme->fl & ~KMAP_NOTIMEOUT) && bcmp(kme->str, *args, *argl) == 0)
3300 break;
3301 if (i == kmap_extn)
3302 {
3303 if (!args[1])
3304 {
3305 Msg(0, "%s: bindkey: keybinding not found", rc_name);
3306 break;
3307 }
3308 kmap_extn += 8;
3309 kmap_exts = (struct kmap_ext *)xrealloc((char *)kmap_exts, kmap_extn * sizeof(*kmap_exts));
3310 kme = kmap_exts + i;
3311 bzero((char *)kme, 8 * sizeof(*kmap_exts));
3312 for (; i < kmap_extn; i++, kme++)
3313 {
3314 kme->str = 0;
3315 kme->dm.nr = kme->mm.nr = kme->um.nr = RC_ILLEGAL;
3316 kme->dm.args = kme->mm.args = kme->um.args = noargs;
3317 }
3318 i -= 8;
3319 kme -= 8;
3320 }
3321 if (df == 0 && kme->dm.nr != RC_ILLEGAL)
3322 used = 1;
3323 if (mf == 0 && kme->mm.nr != RC_ILLEGAL)
3324 used = 1;
3325 if ((df || mf) && kme->um.nr != RC_ILLEGAL)
3326 used = 1;
3327 i += KMAP_KEYS + KMAP_AKEYS;
3328 newact = df ? &kme->dm : mf ? &kme->mm : &kme->um;
3329 }
3330 else
3331 {
3332 for (i = T_CAPS; i < T_OCAPS; i++)
3333 if (strcmp(term[i].tcname, *args) == 0)
3334 break;
3335 if (i == T_OCAPS)
3336 {
3337 Msg(0, "%s: bindkey: unknown key '%s'", rc_name, *args);
3338 break;
3339 }
3340 if (af && i >= T_CURSOR && i < T_OCAPS)
3341 i -= T_CURSOR - KMAP_KEYS;
3342 else
3343 i -= T_CAPS;
3344 newact = df ? &dmtab[i] : mf ? &mmtab[i] : &umtab[i];
3345 }
3346 if (args[1])
3347 {
3348 if ((newnr = FindCommnr(args[1])) == RC_ILLEGAL)
3349 {
3350 Msg(0, "%s: bindkey: unknown command '%s'", rc_name, args[1]);
3351 break;
3352 }
3353 if (CheckArgNum(newnr, args + 2) < 0)
3354 break;
3355 ClearAction(newact);
3356 SaveAction(newact, newnr, args + 2, argl + 2);
3357 if (kf == 0 && args[1])
3358 {
3359 if (kme->str)
3360 free(kme->str);
3361 kme->str = SaveStrn(*args, *argl);
3362 kme->fl = fl | *argl;
3363 }
3364 }
3365 else
3366 ClearAction(newact);
3367 for (display = displays; display; display = display->d_next)
3368 remap(i, args[1] ? 1 : 0);
3369 if (kf == 0 && !args[1])
3370 {
3371 if (!used && kme->str)
3372 {
3373 free(kme->str);
3374 kme->str = 0;
3375 kme->fl = 0;
3376 }
3377 }
3378 display = odisp;
3379 }
3380 break;
3381 case RC_MAPTIMEOUT:
3382 if (*args)
3383 {
3384 if (ParseNum(act, &n))
3385 break;
3386 if (n < 0)
3387 {
3388 Msg(0, "%s: maptimeout: illegal time %d", rc_name, n);
3389 break;
3390 }
3391 maptimeout = n;
3392 }
3393 if (*args == 0 || msgok)
3394 Msg(0, "maptimeout is %dms", maptimeout);
3395 break;
3396 case RC_MAPNOTNEXT:
3397 D_dontmap = 1;
3398 break;
3399 case RC_MAPDEFAULT:
3400 D_mapdefault = 1;
3401 break;
3402 #endif
3403 #ifdef MULTIUSER
3404 case RC_ACLCHG:
3405 case RC_ACLADD:
3406 case RC_ADDACL:
3407 case RC_CHACL:
3408 UsersAcl(NULL, argc, args);
3409 break;
3410 case RC_ACLDEL:
3411 if (UserDel(args[0], NULL))
3412 break;
3413 if (msgok)
3414 Msg(0, "%s removed from acl database", args[0]);
3415 break;
3416 case RC_ACLGRP:
3417 /*
3418 * modify a user to gain or lose rights granted to a group.
3419 * This group is actually a normal user whose rights were defined
3420 * with chacl in the usual way.
3421 */
3422 if (args[1])
3423 {
3424 if (strcmp(args[1], "none")) /* link a user to another user */
3425 {
3426 if (AclLinkUser(args[0], args[1]))
3427 break;
3428 if (msgok)
3429 Msg(0, "User %s joined acl-group %s", args[0], args[1]);
3430 }
3431 else /* remove all groups from user */
3432 {
3433 struct acluser *u;
3434 struct aclusergroup *g;
3435
3436 if (!(u = *FindUserPtr(args[0])))
3437 break;
3438 while ((g = u->u_group))
3439 {
3440 u->u_group = g->next;
3441 free((char *)g);
3442 }
3443 }
3444 }
3445 else /* show all groups of user */
3446 {
3447 char buf[256], *p = buf;
3448 int ngroups = 0;
3449 struct acluser *u;
3450 struct aclusergroup *g;
3451
3452 if (!(u = *FindUserPtr(args[0])))
3453 {
3454 if (msgok)
3455 Msg(0, "User %s does not exist.", args[0]);
3456 break;
3457 }
3458 g = u->u_group;
3459 while (g)
3460 {
3461 ngroups++;
3462 sprintf(p, "%s ", g->u->u_name);
3463 p += strlen(p);
3464 if (p > buf+200)
3465 break;
3466 g = g->next;
3467 }
3468 if (ngroups)
3469 *(--p) = '\0';
3470 Msg(0, "%s's group%s: %s.", args[0], (ngroups == 1) ? "" : "s",
3471 (ngroups == 0) ? "none" : buf);
3472 }
3473 break;
3474 case RC_ACLUMASK:
3475 case RC_UMASK:
3476 while ((s = *args++))
3477 {
3478 char *err = 0;
3479
3480 if (AclUmask(display ? D_user : users, s, &err))
3481 Msg(0, "umask: %s\n", err);
3482 }
3483 break;
3484 case RC_MULTIUSER:
3485 if (ParseOnOff(act, &n))
3486 break;
3487 multi = n ? "" : 0;
3488 chsock();
3489 if (msgok)
3490 Msg(0, "Multiuser mode %s", multi ? "enabled" : "disabled");
3491 break;
3492 #endif /* MULTIUSER */
3493 #ifdef PSEUDOS
3494 case RC_EXEC:
3495 winexec(args);
3496 break;
3497 #endif
3498 #ifdef MULTI
3499 case RC_NONBLOCK:
3500 i = D_nonblock >= 0;
3501 if (*args && ((args[0][0] >= '0' && args[0][0] <= '9') || args[0][0] == '.'))
3502 {
3503 if (ParseNum1000(act, &i))
3504 break;
3505 }
3506 else if (!ParseSwitch(act, &i))
3507 i = i == 0 ? -1 : 1000;
3508 else
3509 break;
3510 if (msgok && i == -1)
3511 Msg(0, "display set to blocking mode");
3512 else if (msgok && i == 0)
3513 Msg(0, "display set to nonblocking mode, no timeout");
3514 else if (msgok)
3515 Msg(0, "display set to nonblocking mode, %.10gs timeout", i/1000.);
3516 D_nonblock = i;
3517 if (D_nonblock <= 0)
3518 evdeq(&D_blockedev);
3519 break;
3520 case RC_DEFNONBLOCK:
3521 if (*args && ((args[0][0] >= '0' && args[0][0] <= '9') || args[0][0] == '.'))
3522 {
3523 if (ParseNum1000(act, &defnonblock))
3524 break;
3525 }
3526 else if (!ParseOnOff(act, &defnonblock))
3527 defnonblock = defnonblock == 0 ? -1 : 1000;
3528 else
3529 break;
3530 if (display && *rc_name)
3531 {
3532 D_nonblock = defnonblock;
3533 if (D_nonblock <= 0)
3534 evdeq(&D_blockedev);
3535 }
3536 break;
3537 #endif
3538 case RC_GR:
3539 #ifdef ENCODINGS
3540 if (fore->w_gr == 2)
3541 fore->w_gr = 0;
3542 #endif
3543 if (ParseSwitch(act, &fore->w_gr) == 0 && msgok)
3544 Msg(0, "Will %suse GR", fore->w_gr ? "" : "not ");
3545 #ifdef ENCODINGS
3546 if (fore->w_gr == 0 && fore->w_FontE)
3547 fore->w_gr = 2;
3548 #endif
3549 break;
3550 case RC_C1:
3551 if (ParseSwitch(act, &fore->w_c1) == 0 && msgok)
3552 Msg(0, "Will %suse C1", fore->w_c1 ? "" : "not ");
3553 break;
3554 #ifdef COLOR
3555 case RC_BCE:
3556 if (ParseSwitch(act, &fore->w_bce) == 0 && msgok)
3557 Msg(0, "Will %serase with background color", fore->w_bce ? "" : "not ");
3558 break;
3559 #endif
3560 #ifdef ENCODINGS
3561 case RC_KANJI:
3562 case RC_ENCODING:
3563 #ifdef UTF8
3564 if (*args && !strcmp(args[0], "-d"))
3565 {
3566 if (!args[1])
3567 Msg(0, "encodings directory is %s", screenencodings ? screenencodings : "<unset>");
3568 else
3569 {
3570 free(screenencodings);
3571 screenencodings = SaveStr(args[1]);
3572 }
3573 break;
3574 }
3575 if (*args && !strcmp(args[0], "-l"))
3576 {
3577 if (!args[1])
3578 Msg(0, "encoding: -l: argument required");
3579 else if (LoadFontTranslation(-1, args[1]))
3580 Msg(0, "encoding: could not load utf8 encoding file");
3581 else if (msgok)
3582 Msg(0, "encoding: utf8 encoding file loaded");
3583 break;
3584 }
3585 #else
3586 if (*args && (!strcmp(args[0], "-l") || !strcmp(args[0], "-d")))
3587 {
3588 if (msgok)
3589 Msg(0, "encoding: screen is not compiled for UTF-8.");
3590 break;
3591 }
3592 #endif
3593 for (i = 0; i < 2; i++)
3594 {
3595 if (args[i] == 0)
3596 break;
3597 if (!strcmp(args[i], "."))
3598 continue;
3599 n = FindEncoding(args[i]);
3600 if (n == -1)
3601 {
3602 Msg(0, "encoding: unknown encoding '%s'", args[i]);
3603 break;
3604 }
3605 if (i == 0 && fore)
3606 {
3607 WinSwitchEncoding(fore, n);
3608 ResetCharsets(fore);
3609 }
3610 else if (i && display)
3611 D_encoding = n;
3612 }
3613 break;
3614 case RC_DEFKANJI:
3615 case RC_DEFENCODING:
3616 n = FindEncoding(*args);
3617 if (n == -1)
3618 {
3619 Msg(0, "defencoding: unknown encoding '%s'", *args);
3620 break;
3621 }
3622 nwin_default.encoding = n;
3623 break;
3624 #endif
3625
3626 #ifdef UTF8
3627 case RC_DEFUTF8:
3628 n = nwin_default.encoding == UTF8;
3629 if (ParseSwitch(act, &n) == 0)
3630 {
3631 nwin_default.encoding = n ? UTF8 : 0;
3632 if (msgok)
3633 Msg(0, "Will %suse UTF-8 encoding for new windows", n ? "" : "not ");
3634 }
3635 break;
3636 case RC_UTF8:
3637 for (i = 0; i < 2; i++)
3638 {
3639 if (i && args[i] == 0)
3640 break;
3641 if (args[i] == 0)
3642 n = fore->w_encoding != UTF8;
3643 else if (strcmp(args[i], "off") == 0)
3644 n = 0;
3645 else if (strcmp(args[i], "on") == 0)
3646 n = 1;
3647 else
3648 {
3649 Msg(0, "utf8: illegal argument (%s)", args[i]);
3650 break;
3651 }
3652 if (i == 0)
3653 {
3654 WinSwitchEncoding(fore, n ? UTF8 : 0);
3655 if (msgok)
3656 Msg(0, "Will %suse UTF-8 encoding", n ? "" : "not ");
3657 }
3658 else if (display)
3659 D_encoding = n ? UTF8 : 0;
3660 if (args[i] == 0)
3661 break;
3662 }
3663 break;
3664 #endif
3665
3666 case RC_PRINTCMD:
3667 if (*args)
3668 {
3669 if (printcmd)
3670 free(printcmd);
3671 printcmd = 0;
3672 if (**args)
3673 printcmd = SaveStr(*args);
3674 }
3675 if (*args == 0 || msgok)
3676 {
3677 if (printcmd)
3678 Msg(0, "using '%s' as print command", printcmd);
3679 else
3680 Msg(0, "using termcap entries for printing");
3681 break;
3682 }
3683 break;
3684
3685 case RC_DIGRAPH:
3686 if (argl && argl[0] > 0 && argl[1] > 0)
3687 {
3688 if (argl[0] != 2)
3689 {
3690 Msg(0, "Two characters expected to define a digraph");
3691 break;
3692 }
3693 i = digraph_find(args[0]);
3694 digraphs[i].d[0] = args[0][0];
3695 digraphs[i].d[1] = args[0][1];
3696 if (!parse_input_int(args[1], argl[1], &digraphs[i].value))
3697 digraphs[i].value = atoi(args[1]);
3698 break;
3699 }
3700 Input("Enter digraph: ", 10, INP_EVERY, digraph_fn, NULL, 0);
3701 if (*args && **args)
3702 {
3703 s = *args;
3704 n = strlen(s);
3705 LayProcess(&s, &n);
3706 }
3707 break;
3708
3709 case RC_DEFHSTATUS:
3710 if (*args == 0)
3711 {
3712 char buf[256];
3713 *buf = 0;
3714 if (nwin_default.hstatus)
3715 AddXChars(buf, sizeof(buf), nwin_default.hstatus);
3716 Msg(0, "default hstatus is '%s'", buf);
3717 break;
3718 }
3719 (void)ParseSaveStr(act, &nwin_default.hstatus);
3720 if (*nwin_default.hstatus == 0)
3721 {
3722 free(nwin_default.hstatus);
3723 nwin_default.hstatus = 0;
3724 }
3725 break;
3726 case RC_HSTATUS:
3727 (void)ParseSaveStr(act, &fore->w_hstatus);
3728 if (*fore->w_hstatus == 0)
3729 {
3730 free(fore->w_hstatus);
3731 fore->w_hstatus = 0;
3732 }
3733 WindowChanged(fore, 'h');
3734 break;
3735
3736 #ifdef FONT
3737 case RC_DEFCHARSET:
3738 case RC_CHARSET:
3739 if (*args == 0)
3740 {
3741 char buf[256];
3742 *buf = 0;
3743 if (nwin_default.charset)
3744 AddXChars(buf, sizeof(buf), nwin_default.charset);
3745 Msg(0, "default charset is '%s'", buf);
3746 break;
3747 }
3748 n = strlen(*args);
3749 if (n == 0 || n > 6)
3750 {
3751 Msg(0, "%s: %s: string has illegal size.", rc_name, comms[nr].name);
3752 break;
3753 }
3754 if (n > 4 && (
3755 ((args[0][4] < '0' || args[0][4] > '3') && args[0][4] != '.') ||
3756 ((args[0][5] < '0' || args[0][5] > '3') && args[0][5] && args[0][5] != '.')))
3757 {
3758 Msg(0, "%s: %s: illegal mapping number.", rc_name, comms[nr].name);
3759 break;
3760 }
3761 if (nr == RC_CHARSET)
3762 {
3763 SetCharsets(fore, *args);
3764 break;
3765 }
3766 if (nwin_default.charset)
3767 free(nwin_default.charset);
3768 nwin_default.charset = SaveStr(*args);
3769 break;
3770 #endif
3771 #ifdef COLOR
3772 case RC_ATTRCOLOR:
3773 s = args[0];
3774 if (*s >= '0' && *s <= '9')
3775 i = *s - '0';
3776 else
3777 for (i = 0; i < 8; i++)
3778 if (*s == "dubrsBiI"[i])
3779 break;
3780 s++;
3781 nr = 0;
3782 if (*s && s[1] && !s[2])
3783 {
3784 if (*s == 'd' && s[1] == 'd')
3785 nr = 3;
3786 else if (*s == '.' && s[1] == 'd')
3787 nr = 2;
3788 else if (*s == 'd' && s[1] == '.')
3789 nr = 1;
3790 else if (*s != '.' || s[1] != '.')
3791 s--;
3792 s += 2;
3793 }
3794 if (*s || i < 0 || i >= 8)
3795 {
3796 Msg(0, "%s: attrcolor: unknown attribute '%s'.", rc_name, args[0]);
3797 break;
3798 }
3799 n = 0;
3800 if (args[1])
3801 n = ParseAttrColor(args[1], args[2], 1);
3802 if (n == -1)
3803 break;
3804 attr2color[i][nr] = n;
3805 n = 0;
3806 for (i = 0; i < 8; i++)
3807 if (attr2color[i][0] || attr2color[i][1] || attr2color[i][2] || attr2color[i][3])
3808 n |= 1 << i;
3809 nattr2color = n;
3810 break;
3811 #endif
3812 case RC_RENDITION:
3813 i = -1;
3814 if (strcmp(args[0], "bell") == 0)
3815 {
3816 i = REND_BELL;
3817 }
3818 else if (strcmp(args[0], "monitor") == 0)
3819 {
3820 i = REND_MONITOR;
3821 }
3822 else if (strcmp(args[0], "so") != 0)
3823 {
3824 Msg(0, "Invalid option '%s' for rendition", args[0]);
3825 break;
3826 }
3827
3828 ++args;
3829 ++argl;
3830
3831 if (i != -1)
3832 {
3833 renditions[i] = ParseAttrColor(args[0], args[1], 1);
3834 WindowChanged((struct win *)0, 'w');
3835 WindowChanged((struct win *)0, 'W');
3836 WindowChanged((struct win *)0, 0);
3837 break;
3838 }
3839
3840 /* We are here, means we want to set the sorendition. */
3841 /* FALLTHROUGH*/
3842 case RC_SORENDITION:
3843 i = 0;
3844 if (*args)
3845 {
3846 i = ParseAttrColor(*args, args[1], 1);
3847 if (i == -1)
3848 break;
3849 ApplyAttrColor(i, &mchar_so);
3850 WindowChanged((struct win *)0, 0);
3851 debug2("--> %x %x\n", mchar_so.attr, mchar_so.color);
3852 }
3853 if (msgok)
3854 #ifdef COLOR
3855 Msg(0, "Standout attributes 0x%02x color 0x%02x", (unsigned char)mchar_so.attr, 0x99 ^ (unsigned char)mchar_so.color);
3856 #else
3857 Msg(0, "Standout attributes 0x%02x ", (unsigned char)mchar_so.attr);
3858 #endif
3859 break;
3860
3861 case RC_SOURCE:
3862 do_source(*args);
3863 break;
3864
3865 #ifdef MULTIUSER
3866 case RC_SU:
3867 s = NULL;
3868 if (!*args)
3869 {
3870 Msg(0, "%s:%s screen login", HostName, SockPath);
3871 InputSu(D_fore, &D_user, NULL);
3872 }
3873 else if (!args[1])
3874 InputSu(D_fore, &D_user, args[0]);
3875 else if (!args[2])
3876 s = DoSu(&D_user, args[0], args[1], "\377");
3877 else
3878 s = DoSu(&D_user, args[0], args[1], args[2]);
3879 if (s)
3880 Msg(0, "%s", s);
3881 break;
3882 #endif /* MULTIUSER */
3883 case RC_SPLIT:
3884 s = args[0];
3885 if (s && !strcmp(s, "-v"))
3886 AddCanvas(SLICE_HORI);
3887 else
3888 AddCanvas(SLICE_VERT);
3889 Activate(-1);
3890 break;
3891 case RC_REMOVE:
3892 RemCanvas();
3893 Activate(-1);
3894 break;
3895 case RC_ONLY:
3896 OneCanvas();
3897 Activate(-1);
3898 break;
3899 case RC_FIT:
3900 D_forecv->c_xoff = D_forecv->c_xs;
3901 D_forecv->c_yoff = D_forecv->c_ys;
3902 RethinkViewportOffsets(D_forecv);
3903 ResizeLayer(D_forecv->c_layer, D_forecv->c_xe - D_forecv->c_xs + 1, D_forecv->c_ye - D_forecv->c_ys + 1, 0);
3904 flayer = D_forecv->c_layer;
3905 LaySetCursor();
3906 break;
3907 case RC_FOCUS:
3908 if (!*args || !strcmp(*args, "down"))
3909 D_forecv = D_forecv->c_next ? D_forecv->c_next : D_cvlist;
3910 else if (!strcmp(*args, "up"))
3911 {
3912 struct canvas *cv;
3913 for (cv = D_cvlist; cv->c_next && cv->c_next != D_forecv; cv = cv->c_next)
3914 ;
3915 D_forecv = cv;
3916 }
3917 else if (!strcmp(*args, "top"))
3918 D_forecv = D_cvlist;
3919 else if (!strcmp(*args, "bottom"))
3920 {
3921 struct canvas *cv;
3922 for (cv = D_cvlist; cv->c_next; cv = cv->c_next)
3923 ;
3924 D_forecv = cv;
3925 }
3926 else
3927 {
3928 Msg(0, "%s: usage: focus [up|down|top|bottom]", rc_name);
3929 break;
3930 }
3931 if ((focusminwidth && (focusminwidth < 0 || D_forecv->c_xe - D_forecv->c_xs + 1 < focusminwidth)) ||
3932 (focusminheight && (focusminheight < 0 || D_forecv->c_ye - D_forecv->c_ys + 1 < focusminheight)))
3933 {
3934 ResizeCanvas(&D_canvas);
3935 RecreateCanvasChain();
3936 RethinkDisplayViewports();
3937 ResizeLayersToCanvases(); /* redisplays */
3938 }
3939 fore = D_fore = Layer2Window(D_forecv->c_layer);
3940 if (D_other == fore)
3941 D_other = 0;
3942 flayer = D_forecv->c_layer;
3943 #ifdef RXVT_OSC
3944 if (D_xtermosc[2] || D_xtermosc[3])
3945 {
3946 Activate(-1);
3947 break;
3948 }
3949 #endif
3950 RefreshHStatus();
3951 #ifdef RXVT_OSC
3952 RefreshXtermOSC();
3953 #endif
3954 flayer = D_forecv->c_layer;
3955 CV_CALL(D_forecv, LayRestore();LaySetCursor());
3956 WindowChanged(0, 'F');
3957 break;
3958 case RC_RESIZE:
3959 i = 0;
3960 if (D_forecv->c_slorient == SLICE_UNKN)
3961 {
3962 Msg(0, "resize: need more than one region");
3963 break;
3964 }
3965 for (; *args; args++)
3966 {
3967 if (!strcmp(*args, "-h"))
3968 i |= RESIZE_FLAG_H;
3969 else if (!strcmp(*args, "-v"))
3970 i |= RESIZE_FLAG_V;
3971 else if (!strcmp(*args, "-b"))
3972 i |= RESIZE_FLAG_H | RESIZE_FLAG_V;
3973 else if (!strcmp(*args, "-p"))
3974 i |= D_forecv->c_slorient == SLICE_VERT ? RESIZE_FLAG_H : RESIZE_FLAG_V;
3975 else if (!strcmp(*args, "-l"))
3976 i |= RESIZE_FLAG_L;
3977 else
3978 break;
3979 }
3980 if (*args && args[1])
3981 {
3982 Msg(0, "%s: usage: resize [-h] [-v] [-l] [num]\n", rc_name);
3983 break;
3984 }
3985 if (*args)
3986 ResizeRegions(*args, i);
3987 else
3988 Input(resizeprompts[i], 20, INP_EVERY, ResizeFin, (char*)0, i);
3989 break;
3990 case RC_SETSID:
3991 (void)ParseSwitch(act, &separate_sids);
3992 break;
3993 case RC_EVAL:
3994 args = SaveArgs(args);
3995 for (i = 0; args[i]; i++)
3996 {
3997 if (args[i][0])
3998 Colonfin(args[i], strlen(args[i]), (char *)0);
3999 free(args[i]);
4000 }
4001 free(args);
4002 break;
4003 case RC_ALTSCREEN:
4004 (void)ParseSwitch(act, &use_altscreen);
4005 if (msgok)
4006 Msg(0, "Will %sdo alternate screen switching", use_altscreen ? "" : "not ");
4007 break;
4008 case RC_MAXWIN:
4009 if (ParseNum(act, &n))
4010 break;
4011 if (n < 1)
4012 Msg(0, "illegal maxwin number specified");
4013 else if (n > maxwin)
4014 Msg(0, "may only decrease maxwin number");
4015 else
4016 maxwin = n;
4017 break;
4018 case RC_BACKTICK:
4019 if (ParseBase(act, *args, &n, 10, "decimal"))
4020 break;
4021 if (!args[1])
4022 setbacktick(n, 0, 0, (char **)0);
4023 else
4024 {
4025 int lifespan, tick;
4026 if (argc < 4)
4027 {
4028 Msg(0, "%s: usage: backtick num [lifespan tick cmd args...]", rc_name);
4029 break;
4030 }
4031 if (ParseBase(act, args[1], &lifespan, 10, "decimal"))
4032 break;
4033 if (ParseBase(act, args[2], &tick, 10, "decimal"))
4034 break;
4035 setbacktick(n, lifespan, tick, SaveArgs(args + 3));
4036 }
4037 WindowChanged(0, '`');
4038 break;
4039 case RC_BLANKER:
4040 #ifdef BLANKER_PRG
4041 if (blankerprg)
4042 {
4043 RunBlanker(blankerprg);
4044 break;
4045 }
4046 #endif
4047 ClearAll();
4048 CursorVisibility(-1);
4049 D_blocked = 4;
4050 break;
4051 #ifdef BLANKER_PRG
4052 case RC_BLANKERPRG:
4053 if (blankerprg)
4054 {
4055 char **pp;
4056 for (pp = blankerprg; *pp; pp++)
4057 free(*pp);
4058 free(blankerprg);
4059 blankerprg = 0;
4060 }
4061 if (args[0][0])
4062 blankerprg = SaveArgs(args);
4063 break;
4064 #endif
4065 case RC_IDLE:
4066 if (*args)
4067 {
4068 struct display *olddisplay = display;
4069 if (!strcmp(*args, "off"))
4070 idletimo = 0;
4071 else if (args[0][0])
4072 idletimo = atoi(*args) * 1000;
4073 if (argc > 1)
4074 {
4075 if ((i = FindCommnr(args[1])) == RC_ILLEGAL)
4076 {
4077 Msg(0, "%s: idle: unknown command '%s'", rc_name, args[1]);
4078 break;
4079 }
4080 if (CheckArgNum(i, args + 2) < 0)
4081 break;
4082 ClearAction(&idleaction);
4083 SaveAction(&idleaction, i, args + 2, argl + 2);
4084 }
4085 for (display = displays; display; display = display->d_next)
4086 ResetIdle();
4087 display = olddisplay;
4088 }
4089 if (msgok)
4090 {
4091 if (idletimo)
4092 Msg(0, "idle timeout %ds, %s", idletimo / 1000, comms[idleaction.nr].name);
4093 else
4094 Msg(0, "idle off");
4095 }
4096 break;
4097 case RC_FOCUSMINSIZE:
4098 for (i = 0; i < 2 && args[i]; i++)
4099 {
4100 if (!strcmp(args[i], "max") || !strcmp(args[i], "_"))
4101 n = -1;
4102 else
4103 n = atoi(args[i]);
4104 if (i == 0)
4105 focusminwidth = n;
4106 else
4107 focusminheight = n;
4108 }
4109 if (msgok)
4110 {
4111 char b[2][20];
4112 for (i = 0; i < 2; i++)
4113 {
4114 n = i == 0 ? focusminwidth : focusminheight;
4115 if (n == -1)
4116 strcpy(b[i], "max");
4117 else
4118 sprintf(b[i], "%d", n);
4119 }
4120 Msg(0, "focus min size is %s %s\n", b[0], b[1]);
4121 }
4122 break;
4123 case RC_GROUP:
4124 if (*args)
4125 {
4126 fore->w_group = 0;
4127 if (args[0][0])
4128 {
4129 fore->w_group = WindowByName(*args);
4130 if (fore->w_group && fore->w_group->w_type != W_TYPE_GROUP)
4131 fore->w_group = 0;
4132 }
4133 WindowChanged((struct win *)0, 'w');
4134 WindowChanged((struct win *)0, 'W');
4135 WindowChanged((struct win *)0, 0);
4136 }
4137 if (msgok)
4138 {
4139 if (fore->w_group)
4140 Msg(0, "window group is %d (%s)\n", fore->w_group->w_number, fore->w_group->w_title);
4141 else
4142 Msg(0, "window belongs to no group");
4143 }
4144 break;
4145 case RC_LAYOUT:
4146 if (!strcmp(args[0], "title"))
4147 {
4148 if (!D_layout)
4149 {
4150 Msg(0, "not on a layout");
4151 break;
4152 }
4153 if (!args[1])
4154 {
4155 Msg(0, "current layout is %d (%s)", D_layout->lay_number, D_layout->lay_title);
4156 break;
4157 }
4158 free(D_layout->lay_title);
4159 D_layout->lay_title= SaveStr(args[1]);
4160 }
4161 else if (!strcmp(args[0], "number"))
4162 {
4163 int old;
4164 struct layout *lay;
4165 if (!D_layout)
4166 {
4167 Msg(0, "not on a layout");
4168 break;
4169 }
4170 if (!args[1])
4171 {
4172 Msg(0, "This is layout %d (%s).\n", D_layout->lay_number, D_layout->lay_title);
4173 break;
4174 }
4175 old = D_layout->lay_number;
4176 n = atoi(args[1]);
4177 if (n < 0 || n >= MAXLAY)
4178 break;
4179 lay = laytab[n];
4180 laytab[n] = D_layout;
4181 D_layout->lay_number = n;
4182 laytab[old] = lay;
4183 if (lay)
4184 lay->lay_number = old;
4185 break;
4186 }
4187 else if (!strcmp(args[0], "autosave"))
4188 {
4189 if (!D_layout)
4190 {
4191 Msg(0, "not on a layout");
4192 break;
4193 }
4194 if (args[1])
4195 {
4196 if (!strcmp(args[1], "on"))
4197 D_layout->lay_autosave = 1;
4198 else if (!strcmp(args[1], "off"))
4199 D_layout->lay_autosave = 0;
4200 else
4201 {
4202 Msg(0, "invalid argument. Give 'on' or 'off");
4203 break;
4204 }
4205 }
4206 if (msgok)
4207 Msg(0, "autosave is %s", D_layout->lay_autosave ? "on" : "off");
4208 }
4209 else if (!strcmp(args[0], "new"))
4210 {
4211 char *t = args[1];
4212 n = 0;
4213 if (t)
4214 {
4215 while (*t >= '0' && *t <= '9')
4216 t++;
4217 if (t != args[1] && (!*t || *t == ':'))
4218 {
4219 n = atoi(args[1]);
4220 if (*t)
4221 t++;
4222 }
4223 else
4224 t = args[1];
4225 }
4226 if (!t || !*t)
4227 t = "layout";
4228 NewLayout(t, n);
4229 Activate(-1);
4230 }
4231 else if (!strcmp(args[0], "save"))
4232 {
4233 if (!args[1])
4234 {
4235 Msg(0, "usage: layout save <name>");
4236 break;
4237 }
4238 SaveLayout(args[1], &D_canvas);
4239 }
4240 else if (!strcmp(args[0], "select"))
4241 {
4242 if (!args[1])
4243 {
4244 Input("Switch to layout: ", 20, INP_COOKED, SelectLayoutFin, NULL, 0);
4245 break;
4246 }
4247 SelectLayoutFin(args[1], strlen(args[1]), (char *)0);
4248 }
4249 else if (!strcmp(args[0], "next"))
4250 {
4251 struct layout *lay = D_layout;
4252 if (lay)
4253 lay = lay->lay_next ? lay->lay_next : layouts;
4254 else
4255 lay = layouts;
4256 if (!lay)
4257 {
4258 Msg(0, "no layout defined");
4259 break;
4260 }
4261 if (lay == D_layout)
4262 break;
4263 LoadLayout(lay, &D_canvas);
4264 Activate(-1);
4265 }
4266 else if (!strcmp(args[0], "prev"))
4267 {
4268 struct layout *lay = D_layout;
4269 if (lay)
4270 {
4271 for (lay = layouts; lay->lay_next && lay->lay_next != D_layout; lay = lay->lay_next)
4272 ;
4273 }
4274 else
4275 lay = layouts;
4276 if (!lay)
4277 {
4278 Msg(0, "no layout defined");
4279 break;
4280 }
4281 if (lay == D_layout)
4282 break;
4283 LoadLayout(lay, &D_canvas);
4284 Activate(-1);
4285 }
4286 else if (!strcmp(args[0], "attach"))
4287 {
4288 if (!args[1])
4289 {
4290 if (!layout_attach)
4291 Msg(0, "no attach layout set");
4292 else if (layout_attach == &layout_last_marker)
4293 Msg(0, "will attach to last layout");
4294 else
4295 Msg(0, "will attach to layout %d (%s)", layout_attach->lay_number, layout_attach->lay_title);
4296 break;
4297 }
4298 if (!strcmp(args[1], ":last"))
4299 layout_attach = &layout_last_marker;
4300 else if (!args[1][0])
4301 layout_attach = 0;
4302 else
4303 {
4304 struct layout *lay;
4305 lay = FindLayout(args[1]);
4306 if (!lay)
4307 {
4308 Msg(0, "unknown layout '%s'", args[1]);
4309 break;
4310 }
4311 layout_attach = lay;
4312 }
4313 }
4314 else if (!strcmp(args[0], "show"))
4315 {
4316 ShowLayouts(-1);
4317 }
4318 else if (!strcmp(args[0], "remove"))
4319 {
4320 struct layout *lay = display ? D_layout : layouts;
4321 if (args[1])
4322 {
4323 lay = layouts ? FindLayout(args[1]) : (struct layout *)0;
4324 if (!lay)
4325 {
4326 Msg(0, "unknown layout '%s'", args[1]);
4327 break;
4328 }
4329 }
4330 if (lay)
4331 RemoveLayout(lay);
4332 }
4333 else
4334 Msg(0, "unknown layout subcommand");
4335 break;
4336 #ifdef DW_CHARS
4337 case RC_CJKWIDTH:
4338 if(ParseSwitch(act, &cjkwidth) == 0)
4339 {
4340 if(msgok)
4341 Msg(0, "Treat ambiguous width characters as %s width", cjkwidth ? "full" : "half");
4342 }
4343 break;
4344 #endif
4345 default:
4346 #ifdef HAVE_BRAILLE
4347 /* key == -2: input from braille keybord, msgok always 0 */
4348 DoBrailleAction(act, key == -2 ? 0 : msgok);
4349 #endif
4350 break;
4351 }
4352 if (display != odisplay)
4353 {
4354 for (display = displays; display; display = display->d_next)
4355 if (display == odisplay)
4356 break;
4357 }
4358 }
4359
4360 void
4361 DoCommand(argv, argl)
4362 char **argv;
4363 int *argl;
4364 {
4365 struct action act;
4366
4367 if ((act.nr = FindCommnr(*argv)) == RC_ILLEGAL)
4368 {
4369 Msg(0, "%s: unknown command '%s'", rc_name, *argv);
4370 return;
4371 }
4372 act.args = argv + 1;
4373 act.argl = argl + 1;
4374 DoAction(&act, -1);
4375 }
4376
4377 static void
4378 SaveAction(act, nr, args, argl)
4379 struct action *act;
4380 int nr;
4381 char **args;
4382 int *argl;
4383 {
4384 register int argc = 0;
4385 char **pp;
4386 int *lp;
4387
4388 if (args)
4389 while (args[argc])
4390 argc++;
4391 if (argc == 0)
4392 {
4393 act->nr = nr;
4394 act->args = noargs;
4395 act->argl = 0;
4396 return;
4397 }
4398 if ((pp = (char **)malloc((unsigned)(argc + 1) * sizeof(char **))) == 0)
4399 Panic(0, strnomem);
4400 if ((lp = (int *)malloc((unsigned)(argc) * sizeof(int *))) == 0)
4401 Panic(0, strnomem);
4402 act->nr = nr;
4403 act->args = pp;
4404 act->argl = lp;
4405 while (argc--)
4406 {
4407 *lp = argl ? *argl++ : (int)strlen(*args);
4408 *pp++ = SaveStrn(*args++, *lp++);
4409 }
4410 *pp = 0;
4411 }
4412
4413 static char **
4414 SaveArgs(args)
4415 char **args;
4416 {
4417 register char **ap, **pp;
4418 register int argc = 0;
4419
4420 while (args[argc])
4421 argc++;
4422 if ((pp = ap = (char **)malloc((unsigned)(argc + 1) * sizeof(char **))) == 0)
4423 Panic(0, strnomem);
4424 while (argc--)
4425 *pp++ = SaveStr(*args++);
4426 *pp = 0;
4427 return ap;
4428 }
4429
4430
4431 /*
4432 * buf is split into argument vector args.
4433 * leading whitespace is removed.
4434 * @!| abbreviations are expanded.
4435 * the end of buffer is recognized by '\0' or an un-escaped '#'.
4436 * " and ' are interpreted.
4437 *
4438 * argc is returned.
4439 */
4440 int
4441 Parse(buf, bufl, args, argl)
4442 char *buf, **args;
4443 int bufl, *argl;
4444 {
4445 register char *p = buf, **ap = args, *pp;
4446 register int delim, argc;
4447 int *lp = argl;
4448
4449 debug2("Parse %d %s\n", bufl, buf);
4450 argc = 0;
4451 pp = buf;
4452 delim = 0;
4453 for (;;)
4454 {
4455 while (*p && (*p == ' ' || *p == '\t'))
4456 ++p;
4457 #ifdef PSEUDOS
4458 if (argc == 0 && *p == '!')
4459 {
4460 *ap++ = "exec";
4461 *lp++ = 4;
4462 p++;
4463 argc++;
4464 continue;
4465 }
4466 #endif
4467 if (*p == '\0' || *p == '#' || *p == '\n')
4468 {
4469 *p = '\0';
4470 for (delim = 0; delim < argc; delim++)
4471 debug1("-- %s\n", args[delim]);
4472 args[argc] = 0;
4473 return argc;
4474 }
4475 if (++argc >= MAXARGS)
4476 {
4477 Msg(0, "%s: too many tokens.", rc_name);
4478 return 0;
4479 }
4480 *ap++ = pp;
4481
4482 debug1("- new arg %s\n", p);
4483 while (*p)
4484 {
4485 if (*p == delim)
4486 delim = 0;
4487 else if (delim != '\'' && *p == '\\' && (p[1] == 'n' || p[1] == 'r' || p[1] == 't' || p[1] == '\'' || p[1] == '"' || p[1] == '\\' || p[1] == '$' || p[1] == '#' || p[1] == '^' || (p[1] >= '0' && p[1] <= '7')))
4488 {
4489 p++;
4490 if (*p >= '0' && *p <= '7')
4491 {
4492 *pp = *p - '0';
4493 if (p[1] >= '0' && p[1] <= '7')
4494 {
4495 p++;
4496 *pp = (*pp << 3) | (*p - '0');
4497 if (p[1] >= '0' && p[1] <= '7')
4498 {
4499 p++;
4500 *pp = (*pp << 3) | (*p - '0');
4501 }
4502 }
4503 pp++;
4504 }
4505 else
4506 {
4507 switch (*p)
4508 {
4509 case 'n': *pp = '\n'; break;
4510 case 'r': *pp = '\r'; break;
4511 case 't': *pp = '\t'; break;
4512 default: *pp = *p; break;
4513 }
4514 pp++;
4515 }
4516 }
4517 else if (delim != '\'' && *p == '$' && (p[1] == '{' || p[1] == ':' || (p[1] >= 'a' && p[1] <= 'z') || (p[1] >= 'A' && p[1] <= 'Z') || (p[1] >= '0' && p[1] <= '9') || p[1] == '_'))
4518
4519 {
4520 char *ps, *pe, op, *v, xbuf[11];
4521 int vl;
4522
4523 ps = ++p;
4524 debug1("- var %s\n", ps);
4525 p++;
4526 while (*p)
4527 {
4528 if (*ps == '{' && *p == '}')
4529 break;
4530 if (*ps == ':' && *p == ':')
4531 break;
4532 if (*ps != '{' && *ps != ':' && (*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z') && (*p < '0' || *p > '9') && *p != '_')
4533 break;
4534 p++;
4535 }
4536 pe = p;
4537 if (*ps == '{' || *ps == ':')
4538 {
4539 if (!*p)
4540 {
4541 Msg(0, "%s: bad variable name.", rc_name);
4542 return 0;
4543 }
4544 p++;
4545 }
4546 op = *pe;
4547 *pe = 0;
4548 debug1("- var is '%s'\n", ps);
4549 if (*ps == ':')
4550 v = gettermcapstring(ps + 1);
4551 else
4552 {
4553 if (*ps == '{')
4554 ps++;
4555 v = xbuf;
4556 if (!strcmp(ps, "TERM"))
4557 v = display ? D_termname : "unknown";
4558 else if (!strcmp(ps, "COLUMNS"))
4559 sprintf(xbuf, "%d", display ? D_width : -1);
4560 else if (!strcmp(ps, "LINES"))
4561 sprintf(xbuf, "%d", display ? D_height : -1);
4562 else
4563 v = getenv(ps);
4564 }
4565 *pe = op;
4566 vl = v ? strlen(v) : 0;
4567 if (vl)
4568 {
4569 debug1("- sub is '%s'\n", v);
4570 if (p - pp < vl)
4571 {
4572 int right = buf + bufl - (p + strlen(p) + 1);
4573 if (right > 0)
4574 {
4575 bcopy(p, p + right, strlen(p) + 1);
4576 p += right;
4577 }
4578 }
4579 if (p - pp < vl)
4580 {
4581 Msg(0, "%s: no space left for variable expansion.", rc_name);
4582 return 0;
4583 }
4584 bcopy(v, pp, vl);
4585 pp += vl;
4586 }
4587 continue;
4588 }
4589 else if (delim != '\'' && *p == '^' && p[1])
4590 {
4591 p++;
4592 *pp++ = *p == '?' ? '\177' : *p & 0x1f;
4593 }
4594 else if (delim == 0 && (*p == '\'' || *p == '"'))
4595 delim = *p;
4596 else if (delim == 0 && (*p == ' ' || *p == '\t' || *p == '\n'))
4597 break;
4598 else
4599 *pp++ = *p;
4600 p++;
4601 }
4602 if (delim)
4603 {
4604 Msg(0, "%s: Missing %c quote.", rc_name, delim);
4605 return 0;
4606 }
4607 if (*p)
4608 p++;
4609 *pp = 0;
4610 debug2("- arg done, '%s' rest %s\n", ap[-1], p);
4611 *lp++ = pp - ap[-1];
4612 pp++;
4613 }
4614 }
4615
4616 void
4617 SetEscape(u, e, me)
4618 struct acluser *u;
4619 int e, me;
4620 {
4621 if (u)
4622 {
4623 u->u_Esc = e;
4624 u->u_MetaEsc = me;
4625 }
4626 else
4627 {
4628 if (users)
4629 {
4630 if (DefaultEsc >= 0)
4631 ClearAction(&ktab[DefaultEsc]);
4632 if (DefaultMetaEsc >= 0)
4633 ClearAction(&ktab[DefaultMetaEsc]);
4634 }
4635 DefaultEsc = e;
4636 DefaultMetaEsc = me;
4637 if (users)
4638 {
4639 if (DefaultEsc >= 0)
4640 {
4641 ClearAction(&ktab[DefaultEsc]);
4642 ktab[DefaultEsc].nr = RC_OTHER;
4643 }
4644 if (DefaultMetaEsc >= 0)
4645 {
4646 ClearAction(&ktab[DefaultMetaEsc]);
4647 ktab[DefaultMetaEsc].nr = RC_META;
4648 }
4649 }
4650 }
4651 }
4652
4653 int
4654 ParseSwitch(act, var)
4655 struct action *act;
4656 int *var;
4657 {
4658 if (*act->args == 0)
4659 {
4660 *var ^= 1;
4661 return 0;
4662 }
4663 return ParseOnOff(act, var);
4664 }
4665
4666 static int
4667 ParseOnOff(act, var)
4668 struct action *act;
4669 int *var;
4670 {
4671 register int num = -1;
4672 char **args = act->args;
4673
4674 if (args[1] == 0)
4675 {
4676 if (strcmp(args[0], "on") == 0)
4677 num = 1;
4678 else if (strcmp(args[0], "off") == 0)
4679 num = 0;
4680 }
4681 if (num < 0)
4682 {
4683 Msg(0, "%s: %s: invalid argument. Give 'on' or 'off'", rc_name, comms[act->nr].name);
4684 return -1;
4685 }
4686 *var = num;
4687 return 0;
4688 }
4689
4690 int
4691 ParseSaveStr(act, var)
4692 struct action *act;
4693 char **var;
4694 {
4695 char **args = act->args;
4696 if (*args == 0 || args[1])
4697 {
4698 Msg(0, "%s: %s: one argument required.", rc_name, comms[act->nr].name);
4699 return -1;
4700 }
4701 if (*var)
4702 free(*var);
4703 *var = SaveStr(*args);
4704 return 0;
4705 }
4706
4707 int
4708 ParseNum(act, var)
4709 struct action *act;
4710 int *var;
4711 {
4712 int i;
4713 char *p, **args = act->args;
4714
4715 p = *args;
4716 if (p == 0 || *p == 0 || args[1])
4717 {
4718 Msg(0, "%s: %s: invalid argument. Give one argument.",
4719 rc_name, comms[act->nr].name);
4720 return -1;
4721 }
4722 i = 0;
4723 while (*p)
4724 {
4725 if (*p >= '0' && *p <= '9')
4726 i = 10 * i + (*p - '0');
4727 else
4728 {
4729 Msg(0, "%s: %s: invalid argument. Give numeric argument.",
4730 rc_name, comms[act->nr].name);
4731 return -1;
4732 }
4733 p++;
4734 }
4735 debug1("ParseNum got %d\n", i);
4736 *var = i;
4737 return 0;
4738 }
4739
4740 static int
4741 ParseNum1000(act, var)
4742 struct action *act;
4743 int *var;
4744 {
4745 int i;
4746 char *p, **args = act->args;
4747 int dig = 0;
4748
4749 p = *args;
4750 if (p == 0 || *p == 0 || args[1])
4751 {
4752 Msg(0, "%s: %s: invalid argument. Give one argument.",
4753 rc_name, comms[act->nr].name);
4754 return -1;
4755 }
4756 i = 0;
4757 while (*p)
4758 {
4759 if (*p >= '0' && *p <= '9')
4760 {
4761 if (dig < 4)
4762 i = 10 * i + (*p - '0');
4763 else if (dig == 4 && *p >= '5')
4764 i++;
4765 if (dig)
4766 dig++;
4767 }
4768 else if (*p == '.' && !dig)
4769 dig++;
4770 else
4771 {
4772 Msg(0, "%s: %s: invalid argument. Give floating point argument.",
4773 rc_name, comms[act->nr].name);
4774 return -1;
4775 }
4776 p++;
4777 }
4778 if (dig == 0)
4779 i *= 1000;
4780 else
4781 while (dig++ < 4)
4782 i *= 10;
4783 if (i < 0)
4784 i = (int)((unsigned int)~0 >> 1);
4785 debug1("ParseNum1000 got %d\n", i);
4786 *var = i;
4787 return 0;
4788 }
4789
4790 static struct win *
4791 WindowByName(s)
4792 char *s;
4793 {
4794 struct win *p;
4795
4796 for (p = windows; p; p = p->w_next)
4797 if (!strcmp(p->w_title, s))
4798 return p;
4799 for (p = windows; p; p = p->w_next)
4800 if (!strncmp(p->w_title, s, strlen(s)))
4801 return p;
4802 return 0;
4803 }
4804
4805 static int
4806 WindowByNumber(str)
4807 char *str;
4808 {
4809 int i;
4810 char *s;
4811
4812 for (i = 0, s = str; *s; s++)
4813 {
4814 if (*s < '0' || *s > '9')
4815 break;
4816 i = i * 10 + (*s - '0');
4817 }
4818 return *s ? -1 : i;
4819 }
4820
4821 /*
4822 * Get window number from Name or Number string.
4823 * Numbers are tried first, then names, a prefix match suffices.
4824 * Be careful when assigning numeric strings as WindowTitles.
4825 */
4826 int
4827 WindowByNoN(str)
4828 char *str;
4829 {
4830 int i;
4831 struct win *p;
4832
4833 if ((i = WindowByNumber(str)) < 0 || i >= MAXWIN)
4834 {
4835 if ((p = WindowByName(str)))
4836 return p->w_number;
4837 return -1;
4838 }
4839 return i;
4840 }
4841
4842 static int
4843 ParseWinNum(act, var)
4844 struct action *act;
4845 int *var;
4846 {
4847 char **args = act->args;
4848 int i = 0;
4849
4850 if (*args == 0 || args[1])
4851 {
4852 Msg(0, "%s: %s: one argument required.", rc_name, comms[act->nr].name);
4853 return -1;
4854 }
4855
4856 i = WindowByNoN(*args);
4857 if (i < 0)
4858 {
4859 Msg(0, "%s: %s: invalid argument. Give window number or name.",
4860 rc_name, comms[act->nr].name);
4861 return -1;
4862 }
4863 debug1("ParseWinNum got %d\n", i);
4864 *var = i;
4865 return 0;
4866 }
4867
4868 static int
4869 ParseBase(act, p, var, base, bname)
4870 struct action *act;
4871 char *p;
4872 int *var;
4873 int base;
4874 char *bname;
4875 {
4876 int i = 0;
4877 int c;
4878
4879 if (*p == 0)
4880 {
4881 Msg(0, "%s: %s: empty argument.", rc_name, comms[act->nr].name);
4882 return -1;
4883 }
4884 while ((c = *p++))
4885 {
4886 if (c >= 'a' && c <= 'z')
4887 c -= 'a' - 'A';
4888 if (c >= 'A' && c <= 'Z')
4889 c -= 'A' - ('0' + 10);
4890 c -= '0';
4891 if (c < 0 || c >= base)
4892 {
4893 Msg(0, "%s: %s: argument is not %s.", rc_name, comms[act->nr].name, bname);
4894 return -1;
4895 }
4896 i = base * i + c;
4897 }
4898 debug1("ParseBase got %d\n", i);
4899 *var = i;
4900 return 0;
4901 }
4902
4903 static int
4904 IsNum(s, base)
4905 register char *s;
4906 register int base;
4907 {
4908 for (base += '0'; *s; ++s)
4909 if (*s < '0' || *s > base)
4910 return 0;
4911 return 1;
4912 }
4913
4914 int
4915 IsNumColon(s, base, p, psize)
4916 int base, psize;
4917 char *s, *p;
4918 {
4919 char *q;
4920 if ((q = rindex(s, ':')) != 0)
4921 {
4922 strncpy(p, q + 1, psize - 1);
4923 p[psize - 1] = '\0';
4924 *q = '\0';
4925 }
4926 else
4927 *p = '\0';
4928 return IsNum(s, base);
4929 }
4930
4931 void
4932 SwitchWindow(n)
4933 int n;
4934 {
4935 struct win *p;
4936
4937 debug1("SwitchWindow %d\n", n);
4938 if (n < 0 || n >= MAXWIN)
4939 {
4940 ShowWindows(-1);
4941 return;
4942 }
4943 if ((p = wtab[n]) == 0)
4944 {
4945 ShowWindows(n);
4946 return;
4947 }
4948 if (display == 0)
4949 {
4950 fore = p;
4951 return;
4952 }
4953 if (p == D_fore)
4954 {
4955 Msg(0, "This IS window %d (%s).", n, p->w_title);
4956 return;
4957 }
4958 #ifdef MULTIUSER
4959 if (AclCheckPermWin(D_user, ACL_READ, p))
4960 {
4961 Msg(0, "Access to window %d denied.", p->w_number);
4962 return;
4963 }
4964 #endif
4965 SetForeWindow(p);
4966 Activate(fore->w_norefresh);
4967 }
4968
4969
4970 void
4971 SetCanvasWindow(cv, wi)
4972 struct canvas *cv;
4973 struct win *wi;
4974 {
4975 struct win *p = 0, **pp;
4976 struct layer *l;
4977 struct canvas *cvp, **cvpp;
4978
4979 l = cv->c_layer;
4980 display = cv->c_display;
4981
4982 if (l)
4983 {
4984 /* remove old layer */
4985 for (cvpp = &l->l_cvlist; (cvp = *cvpp); cvpp = &cvp->c_lnext)
4986 if (cvp == cv)
4987 break;
4988 ASSERT(cvp);
4989 *cvpp = cvp->c_lnext;
4990
4991 p = Layer2Window(l);
4992 l = cv->c_layer;
4993 cv->c_layer = 0;
4994
4995 if (p && cv == D_forecv)
4996 {
4997 #ifdef MULTIUSER
4998 ReleaseAutoWritelock(display, p);
4999 #endif
5000 if (p->w_silence)
5001 {
5002 SetTimeout(&p->w_silenceev, p->w_silencewait * 1000);
5003 evenq(&p->w_silenceev);
5004 }
5005 D_other = fore;
5006 D_fore = 0;
5007 }
5008 if (l->l_cvlist == 0 && (p == 0 || l != p->w_savelayer))
5009 KillLayerChain(l);
5010 }
5011
5012 /* find right layer to display on canvas */
5013 if (wi && wi->w_type != W_TYPE_GROUP)
5014 {
5015 l = &wi->w_layer;
5016 if (wi->w_savelayer && (wi->w_blocked || wi->w_savelayer->l_cvlist == 0))
5017 l = wi->w_savelayer;
5018 }
5019 else
5020 {
5021 l = &cv->c_blank;
5022 if (wi)
5023 l->l_data = (char *)wi;
5024 else
5025 l->l_data = 0;
5026 }
5027
5028 /* add our canvas to the layer's canvaslist */
5029 ASSERT(l->l_cvlist != cv);
5030 cv->c_lnext = l->l_cvlist;
5031 l->l_cvlist = cv;
5032 cv->c_layer = l;
5033 cv->c_xoff = cv->c_xs;
5034 cv->c_yoff = cv->c_ys;
5035 RethinkViewportOffsets(cv);
5036
5037 if (flayer == 0)
5038 flayer = l;
5039
5040 if (wi && wi->w_type == W_TYPE_GROUP)
5041 {
5042 /* auto-start windowlist on groups */
5043 struct display *d = display;
5044 struct layer *oldflayer = flayer;
5045 flayer = l;
5046 display_wlist(0, 0, wi);
5047 flayer = oldflayer;
5048 display = d;
5049 }
5050
5051 if (wi && D_other == wi)
5052 D_other = wi->w_next; /* Might be 0, but that's OK. */
5053 if (cv == D_forecv)
5054 {
5055 D_fore = wi;
5056 fore = D_fore; /* XXX ? */
5057 if (wi)
5058 {
5059 #ifdef MULTIUSER
5060 ObtainAutoWritelock(display, wi);
5061 #endif
5062 /*
5063 * Place the window at the head of the most-recently-used list
5064 */
5065 if (windows != wi)
5066 {
5067 for (pp = &windows; (p = *pp); pp = &p->w_next)
5068 if (p == wi)
5069 break;
5070 ASSERT(p);
5071 *pp = p->w_next;
5072 p->w_next = windows;
5073 windows = p;
5074 WListLinkChanged();
5075 }
5076 }
5077 }
5078 }
5079
5080
5081 /*
5082 * SetForeWindow changes the window in the input focus of the display.
5083 * Puts window wi in canvas display->d_forecv.
5084 */
5085 void
5086 SetForeWindow(wi)
5087 struct win *wi;
5088 {
5089 struct win *p;
5090 if (display == 0)
5091 {
5092 fore = wi;
5093 return;
5094 }
5095 p = Layer2Window(D_forecv->c_layer);
5096 SetCanvasWindow(D_forecv, wi);
5097 if (p)
5098 WindowChanged(p, 'u');
5099 if (wi)
5100 WindowChanged(wi, 'u');
5101 flayer = D_forecv->c_layer;
5102 /* Activate called afterwards, so no RefreshHStatus needed */
5103 }
5104
5105
5106 /*****************************************************************/
5107
5108 /*
5109 * Activate - make fore window active
5110 * norefresh = -1 forces a refresh, disregard all_norefresh then.
5111 */
5112 void
5113 Activate(norefresh)
5114 int norefresh;
5115 {
5116 debug1("Activate(%d)\n", norefresh);
5117 if (display == 0)
5118 return;
5119 if (D_status)
5120 {
5121 Msg(0, "%s", ""); /* wait till mintime (keep gcc quiet) */
5122 RemoveStatus();
5123 }
5124
5125 if (MayResizeLayer(D_forecv->c_layer))
5126 ResizeLayer(D_forecv->c_layer, D_forecv->c_xe - D_forecv->c_xs + 1, D_forecv->c_ye - D_forecv->c_ys + 1, display);
5127
5128 fore = D_fore;
5129 if (fore)
5130 {
5131 /* XXX ? */
5132 if (fore->w_monitor != MON_OFF)
5133 fore->w_monitor = MON_ON;
5134 fore->w_bell = BELL_ON;
5135 WindowChanged(fore, 'f');
5136
5137 #if 0
5138 if (ResizeDisplay(fore->w_width, fore->w_height))
5139 {
5140 debug2("Cannot resize from (%d,%d)", D_width, D_height);
5141 debug2(" to (%d,%d) -> resize window\n", fore->w_width, fore->w_height);
5142 DoResize(D_width, D_height);
5143 }
5144 #endif
5145 }
5146 Redisplay(norefresh + all_norefresh);
5147 }
5148
5149
5150 static int
5151 NextWindow()
5152 {
5153 register struct win **pp;
5154 int n = fore ? fore->w_number : MAXWIN;
5155 struct win *group = fore ? fore->w_group : 0;
5156
5157 for (pp = fore ? wtab + n + 1 : wtab; pp != wtab + n; pp++)
5158 {
5159 if (pp == wtab + MAXWIN)
5160 pp = wtab;
5161 if (*pp)
5162 {
5163 if (!fore || group == (*pp)->w_group)
5164 break;
5165 }
5166 }
5167 if (pp == wtab + n)
5168 return -1;
5169 return pp - wtab;
5170 }
5171
5172 static int
5173 PreviousWindow()
5174 {
5175 register struct win **pp;
5176 int n = fore ? fore->w_number : -1;
5177 struct win *group = fore ? fore->w_group : 0;
5178
5179 for (pp = wtab + n - 1; pp != wtab + n; pp--)
5180 {
5181 if (pp == wtab - 1)
5182 pp = wtab + MAXWIN - 1;
5183 if (*pp)
5184 {
5185 if (!fore || group == (*pp)->w_group)
5186 break;
5187 }
5188 }
5189 if (pp == wtab + n)
5190 return -1;
5191 return pp - wtab;
5192 }
5193
5194 static int
5195 MoreWindows()
5196 {
5197 char *m = "No other window.";
5198 if (windows && (fore == 0 || windows->w_next))
5199 return 1;
5200 if (fore == 0)
5201 {
5202 Msg(0, "No window available");
5203 return 0;
5204 }
5205 Msg(0, m, fore->w_number); /* other arg for nethack */
5206 return 0;
5207 }
5208
5209 static void
5210 UpdateLayoutCanvas(cv, wi)
5211 struct canvas *cv;
5212 struct win *wi;
5213 {
5214 for (; cv; cv = cv->c_slnext)
5215 {
5216 if (cv->c_layer && Layer2Window(cv->c_layer) == wi)
5217 {
5218 /* A simplistic version of SetCanvasWindow(cv, 0) */
5219 struct layer *l = cv->c_layer;
5220 cv->c_layer = 0;
5221 if (l->l_cvlist == 0 && (wi == 0 || l != wi->w_savelayer))
5222 KillLayerChain(l);
5223 l = &cv->c_blank;
5224 l->l_data = 0;
5225 if (l->l_cvlist != cv)
5226 {
5227 cv->c_lnext = l->l_cvlist;
5228 l->l_cvlist = cv;
5229 }
5230 cv->c_layer = l;
5231 /* Do not end here. Multiple canvases can have the same window */
5232 }
5233
5234 if (cv->c_slperp)
5235 UpdateLayoutCanvas(cv->c_slperp, wi);
5236 }
5237 }
5238
5239 void
5240 KillWindow(wi)
5241 struct win *wi;
5242 {
5243 struct win **pp, *p;
5244 struct canvas *cv;
5245 int gotone;
5246 struct layout *lay;
5247
5248 /*
5249 * Remove window from linked list.
5250 */
5251 for (pp = &windows; (p = *pp); pp = &p->w_next)
5252 if (p == wi)
5253 break;
5254 ASSERT(p);
5255 *pp = p->w_next;
5256 wi->w_inlen = 0;
5257 wtab[wi->w_number] = 0;
5258
5259 if (windows == 0)
5260 {
5261 FreeWindow(wi);
5262 Finit(0);
5263 }
5264
5265 /*
5266 * switch to different window on all canvases
5267 */
5268 for (display = displays; display; display = display->d_next)
5269 {
5270 gotone = 0;
5271 for (cv = D_cvlist; cv; cv = cv->c_next)
5272 {
5273 if (Layer2Window(cv->c_layer) != wi)
5274 continue;
5275 /* switch to other window */
5276 SetCanvasWindow(cv, FindNiceWindow(D_other, 0));
5277 gotone = 1;
5278 }
5279 if (gotone)
5280 {
5281 #ifdef ZMODEM
5282 if (wi->w_zdisplay == display)
5283 {
5284 D_blocked = 0;
5285 D_readev.condpos = D_readev.condneg = 0;
5286 }
5287 #endif
5288 Activate(-1);
5289 }
5290 }
5291
5292 /* do the same for the layouts */
5293 for (lay = layouts; lay; lay = lay->lay_next)
5294 UpdateLayoutCanvas(&lay->lay_canvas, wi);
5295
5296 FreeWindow(wi);
5297 WindowChanged((struct win *)0, 'w');
5298 WindowChanged((struct win *)0, 'W');
5299 WindowChanged((struct win *)0, 0);
5300 }
5301
5302 static void
5303 LogToggle(on)
5304 int on;
5305 {
5306 char buf[1024];
5307
5308 if ((fore->w_log != 0) == on)
5309 {
5310 if (display && !*rc_name)
5311 Msg(0, "You are %s logging.", on ? "already" : "not");
5312 return;
5313 }
5314 if (fore->w_log != 0)
5315 {
5316 Msg(0, "Logfile \"%s\" closed.", fore->w_log->name);
5317 logfclose(fore->w_log);
5318 fore->w_log = 0;
5319 WindowChanged(fore, 'f');
5320 return;
5321 }
5322 if (DoStartLog(fore, buf, sizeof(buf)))
5323 {
5324 Msg(errno, "Error opening logfile \"%s\"", buf);
5325 return;
5326 }
5327 if (ftell(fore->w_log->fp) == 0)
5328 Msg(0, "Creating logfile \"%s\".", fore->w_log->name);
5329 else
5330 Msg(0, "Appending to logfile \"%s\".", fore->w_log->name);
5331 WindowChanged(fore, 'f');
5332 }
5333
5334 char *
5335 AddWindows(buf, len, flags, where)
5336 char *buf;
5337 int len;
5338 int flags;
5339 int where;
5340 {
5341 register char *s, *ss;
5342 register struct win **pp, *p;
5343 register char *cmd;
5344 int l;
5345
5346 s = ss = buf;
5347 if ((flags & 8) && where < 0)
5348 {
5349 *s = 0;
5350 return ss;
5351 }
5352 for (pp = ((flags & 4) && where >= 0) ? wtab + where + 1: wtab; pp < wtab + MAXWIN; pp++)
5353 {
5354 int rend = -1;
5355 if (pp - wtab == where && ss == buf)
5356 ss = s;
5357 if ((p = *pp) == 0)
5358 continue;
5359 if ((flags & 1) && display && p == D_fore)
5360 continue;
5361 if (D_fore && D_fore->w_group != p->w_group)
5362 continue;
5363
5364 cmd = p->w_title;
5365 l = strlen(cmd);
5366 if (l > 20)
5367 l = 20;
5368 if (s - buf + l > len - 24)
5369 break;
5370 if (s > buf || (flags & 4))
5371 {
5372 *s++ = ' ';
5373 *s++ = ' ';
5374 }
5375 if (p->w_number == where)
5376 {
5377 ss = s;
5378 if (flags & 8)
5379 break;
5380 }
5381 if (!(flags & 4) || where < 0 || ((flags & 4) && where < p->w_number))
5382 {
5383 if (p->w_monitor == MON_DONE && renditions[REND_MONITOR] != -1)
5384 rend = renditions[REND_MONITOR];
5385 else if ((p->w_bell == BELL_DONE || p->w_bell == BELL_FOUND) && renditions[REND_BELL] != -1)
5386 rend = renditions[REND_BELL];
5387 }
5388 if (rend != -1)
5389 AddWinMsgRend(s, rend);
5390 sprintf(s, "%d", p->w_number);
5391 s += strlen(s);
5392 if (display && p == D_fore)
5393 *s++ = '*';
5394 if (!(flags & 2))
5395 {
5396 if (display && p == D_other)
5397 *s++ = '-';
5398 s = AddWindowFlags(s, len, p);
5399 }
5400 *s++ = ' ';
5401 strncpy(s, cmd, l);
5402 s += l;
5403 if (rend != -1)
5404 AddWinMsgRend(s, -1);
5405 }
5406 *s = 0;
5407 return ss;
5408 }
5409
5410 char *
5411 AddWindowFlags(buf, len, p)
5412 char *buf;
5413 int len;
5414 struct win *p;
5415 {
5416 char *s = buf;
5417 if (p == 0 || len < 12)
5418 {
5419 *s = 0;
5420 return s;
5421 }
5422 #if 0
5423 if (display && p == D_fore)
5424 *s++ = '*';
5425 if (display && p == D_other)
5426 *s++ = '-';
5427 #endif
5428 if (p->w_layer.l_cvlist && p->w_layer.l_cvlist->c_lnext)
5429 *s++ = '&';
5430 if (p->w_monitor == MON_DONE
5431 #ifdef MULTIUSER
5432 && (ACLBYTE(p->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id))
5433 #endif
5434 )
5435 *s++ = '@';
5436 if (p->w_bell == BELL_DONE)
5437 *s++ = '!';
5438 #ifdef UTMPOK
5439 if (p->w_slot != (slot_t) 0 && p->w_slot != (slot_t) -1)
5440 *s++ = '$';
5441 #endif
5442 if (p->w_log != 0)
5443 {
5444 strcpy(s, "(L)");
5445 s += 3;
5446 }
5447 if (p->w_ptyfd < 0 && p->w_type != W_TYPE_GROUP)
5448 *s++ = 'Z';
5449 *s = 0;
5450 return s;
5451 }
5452
5453 char *
5454 AddOtherUsers(buf, len, p)
5455 char *buf;
5456 int len;
5457 struct win *p;
5458 {
5459 struct display *d, *olddisplay = display;
5460 struct canvas *cv;
5461 char *s;
5462 int l;
5463
5464 s = buf;
5465 for (display = displays; display; display = display->d_next)
5466 {
5467 if (olddisplay && D_user == olddisplay->d_user)
5468 continue;
5469 for (cv = D_cvlist; cv; cv = cv->c_next)
5470 if (Layer2Window(cv->c_layer) == p)
5471 break;
5472 if (!cv)
5473 continue;
5474 for (d = displays; d && d != display; d = d->d_next)
5475 if (D_user == d->d_user)
5476 break;
5477 if (d && d != display)
5478 continue;
5479 if (len > 1 && s != buf)
5480 {
5481 *s++ = ',';
5482 len--;
5483 }
5484 l = strlen(D_user->u_name);
5485 if (l + 1 > len)
5486 break;
5487 strcpy(s, D_user->u_name);
5488 s += l;
5489 len -= l;
5490 }
5491 *s = 0;
5492 display = olddisplay;
5493 return s;
5494 }
5495
5496 void
5497 ShowWindows(where)
5498 int where;
5499 {
5500 char buf[1024];
5501 char *s, *ss;
5502
5503 if (!display)
5504 return;
5505 if (where == -1 && D_fore)
5506 where = D_fore->w_number;
5507 ss = AddWindows(buf, sizeof(buf), 0, where);
5508 s = buf + strlen(buf);
5509 if (ss - buf > D_width / 2)
5510 {
5511 ss -= D_width / 2;
5512 if (s - ss < D_width)
5513 {
5514 ss = s - D_width;
5515 if (ss < buf)
5516 ss = buf;
5517 }
5518 }
5519 else
5520 ss = buf;
5521 Msg(0, "%s", ss);
5522 }
5523
5524 static void
5525 ShowInfo()
5526 {
5527 char buf[512], *p;
5528 register struct win *wp = fore;
5529 register int i;
5530
5531 if (wp == 0)
5532 {
5533 Msg(0, "(%d,%d)/(%d,%d) no window", D_x + 1, D_y + 1, D_width, D_height);
5534 return;
5535 }
5536 p = buf;
5537 if (buf < (p += GetAnsiStatus(wp, p)))
5538 *p++ = ' ';
5539 sprintf(p, "(%d,%d)/(%d,%d)",
5540 wp->w_x + 1, wp->w_y + 1, wp->w_width, wp->w_height);
5541 #ifdef COPY_PASTE
5542 sprintf(p += strlen(p), "+%d", wp->w_histheight);
5543 #endif
5544 sprintf(p += strlen(p), " %c%sflow",
5545 (wp->w_flow & FLOW_NOW) ? '+' : '-',
5546 (wp->w_flow & FLOW_AUTOFLAG) ? "" :
5547 ((wp->w_flow & FLOW_AUTO) ? "(+)" : "(-)"));
5548 if (!wp->w_wrap) sprintf(p += strlen(p), " -wrap");
5549 if (wp->w_insert) sprintf(p += strlen(p), " ins");
5550 if (wp->w_origin) sprintf(p += strlen(p), " org");
5551 if (wp->w_keypad) sprintf(p += strlen(p), " app");
5552 if (wp->w_log) sprintf(p += strlen(p), " log");
5553 if (wp->w_monitor != MON_OFF
5554 #ifdef MULTIUSER
5555 && (ACLBYTE(wp->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id))
5556 #endif
5557 )
5558 sprintf(p += strlen(p), " mon");
5559 if (wp->w_mouse) sprintf(p += strlen(p), " mouse");
5560 #ifdef COLOR
5561 if (wp->w_bce) sprintf(p += strlen(p), " bce");
5562 #endif
5563 if (!wp->w_c1) sprintf(p += strlen(p), " -c1");
5564 if (wp->w_norefresh) sprintf(p += strlen(p), " nored");
5565
5566 p += strlen(p);
5567 #ifdef FONT
5568 # ifdef ENCODINGS
5569 if (wp->w_encoding && (display == 0 || D_encoding != wp->w_encoding || EncodingDefFont(wp->w_encoding) <= 0))
5570 {
5571 *p++ = ' ';
5572 strcpy(p, EncodingName(wp->w_encoding));
5573 p += strlen(p);
5574 }
5575 # ifdef UTF8
5576 if (wp->w_encoding != UTF8)
5577 # endif
5578 # endif
5579 if (D_CC0 || (D_CS0 && *D_CS0))
5580 {
5581 if (wp->w_gr == 2)
5582 {
5583 sprintf(p, " G%c", wp->w_Charset + '0');
5584 if (wp->w_FontE >= ' ')
5585 p[3] = wp->w_FontE;
5586 else
5587 {
5588 p[3] = '^';
5589 p[4] = wp->w_FontE ^ 0x40;
5590 p++;
5591 }
5592 p[4] = '[';
5593 p++;
5594 }
5595 else if (wp->w_gr)
5596 sprintf(p++, " G%c%c[", wp->w_Charset + '0', wp->w_CharsetR + '0');
5597 else
5598 sprintf(p, " G%c[", wp->w_Charset + '0');
5599 p += 4;
5600 for (i = 0; i < 4; i++)
5601 {
5602 if (wp->w_charsets[i] == ASCII)
5603 *p++ = 'B';
5604 else if (wp->w_charsets[i] >= ' ')
5605 *p++ = wp->w_charsets[i];
5606 else
5607 {
5608 *p++ = '^';
5609 *p++ = wp->w_charsets[i] ^ 0x40;
5610 }
5611 }
5612 *p++ = ']';
5613 *p = 0;
5614 }
5615 #endif
5616
5617 if (wp->w_type == W_TYPE_PLAIN)
5618 {
5619 /* add info about modem control lines */
5620 *p++ = ' ';
5621 TtyGetModemStatus(wp->w_ptyfd, p);
5622 }
5623 #ifdef BUILTIN_TELNET
5624 else if (wp->w_type == W_TYPE_TELNET)
5625 {
5626 *p++ = ' ';
5627 TelStatus(wp, p, sizeof(buf) - 1 - (p - buf));
5628 }
5629 #endif
5630 Msg(0, "%s %d(%s)", buf, wp->w_number, wp->w_title);
5631 }
5632
5633 static void
5634 ShowDInfo()
5635 {
5636 char buf[512], *p;
5637 if (display == 0)
5638 return;
5639 p = buf;
5640 sprintf(p, "(%d,%d)", D_width, D_height),
5641 p += strlen(p);
5642 #ifdef ENCODINGS
5643 if (D_encoding)
5644 {
5645 *p++ = ' ';
5646 strcpy(p, EncodingName(D_encoding));
5647 p += strlen(p);
5648 }
5649 #endif
5650 if (D_CXT)
5651 {
5652 strcpy(p, " xterm");
5653 p += strlen(p);
5654 }
5655 #ifdef COLOR
5656 if (D_hascolor)
5657 {
5658 strcpy(p, " color");
5659 p += strlen(p);
5660 }
5661 #endif
5662 #ifdef FONT
5663 if (D_CG0)
5664 {
5665 strcpy(p, " iso2022");
5666 p += strlen(p);
5667 }
5668 else if (D_CS0 && *D_CS0)
5669 {
5670 strcpy(p, " altchar");
5671 p += strlen(p);
5672 }
5673 #endif
5674 Msg(0, "%s", buf);
5675 }
5676
5677 static void
5678 AKAfin(buf, len, data)
5679 char *buf;
5680 int len;
5681 char *data; /* dummy */
5682 {
5683 ASSERT(display);
5684 if (len && fore)
5685 ChangeAKA(fore, buf, strlen(buf));
5686 }
5687
5688 static void
5689 InputAKA()
5690 {
5691 char *s, *ss;
5692 int n;
5693 Input("Set window's title to: ", sizeof(fore->w_akabuf) - 1, INP_COOKED, AKAfin, NULL, 0);
5694 s = fore->w_title;
5695 if (!s)
5696 return;
5697 for (; *s; s++)
5698 {
5699 if ((*(unsigned char *)s & 0x7f) < 0x20 || *s == 0x7f)
5700 continue;
5701 ss = s;
5702 n = 1;
5703 LayProcess(&ss, &n);
5704 }
5705 }
5706
5707 static void
5708 Colonfin(buf, len, data)
5709 char *buf;
5710 int len;
5711 char *data; /* dummy */
5712 {
5713 char mbuf[256];
5714
5715 RemoveStatus();
5716 if (buf[len] == '\t')
5717 {
5718 int m, x;
5719 int l = 0, r = RC_LAST;
5720 int showmessage = 0;
5721 char *s = buf;
5722
5723 while (*s && s - buf < len)
5724 if (*s++ == ' ')
5725 return;
5726
5727 /* Showing a message when there's no hardstatus or caption cancels the input */
5728 if (display &&
5729 (captionalways || D_has_hstatus == HSTATUS_LASTLINE || (D_canvas.c_slperp && D_canvas.c_slperp->c_slnext)))
5730 showmessage = 1;
5731
5732 while (l <= r)
5733 {
5734 m = (l + r) / 2;
5735 x = strncmp(buf, comms[m].name, len);
5736 if (x > 0)
5737 l = m + 1;
5738 else if (x < 0)
5739 r = m - 1;
5740 else
5741 {
5742 s = mbuf;
5743 for (l = m - 1; l >= 0 && strncmp(buf, comms[l].name, len) == 0; l--)
5744 ;
5745 for (m = ++l; m <= r && strncmp(buf, comms[m].name, len) == 0 && s - mbuf < sizeof(mbuf); m++)
5746 s += snprintf(s, sizeof(mbuf) - (s - mbuf), " %s", comms[m].name);
5747 if (l < m - 1)
5748 {
5749 if (showmessage)
5750 Msg(0, "Possible commands:%s", mbuf);
5751 }
5752 else
5753 {
5754 s = mbuf;
5755 len = snprintf(mbuf, sizeof(mbuf), "%s \t", comms[l].name + len);
5756 if (len > 0 && len < sizeof(mbuf))
5757 LayProcess(&s, &len);
5758 }
5759 break;
5760 }
5761 }
5762 if (l > r && showmessage)
5763 Msg(0, "No commands matching '%*s'", len, buf);
5764 return;
5765 }
5766
5767 if (!len || buf[len])
5768 return;
5769
5770 len = strlen(buf) + 1;
5771 if (len > (int)sizeof(mbuf))
5772 RcLine(buf, len);
5773 else
5774 {
5775 bcopy(buf, mbuf, len);
5776 RcLine(mbuf, sizeof mbuf);
5777 }
5778 }
5779
5780 static void
5781 SelectFin(buf, len, data)
5782 char *buf;
5783 int len;
5784 char *data; /* dummy */
5785 {
5786 int n;
5787
5788 if (!len || !display)
5789 return;
5790 if (len == 1 && *buf == '-')
5791 {
5792 SetForeWindow((struct win *)0);
5793 Activate(0);
5794 return;
5795 }
5796 if ((n = WindowByNoN(buf)) < 0)
5797 return;
5798 SwitchWindow(n);
5799 }
5800
5801 static void
5802 SelectLayoutFin(buf, len, data)
5803 char *buf;
5804 int len;
5805 char *data; /* dummy */
5806 {
5807 struct layout *lay;
5808
5809 if (!len || !display)
5810 return;
5811 if (len == 1 && *buf == '-')
5812 {
5813 LoadLayout((struct layout *)0, (struct canvas *)0);
5814 Activate(0);
5815 return;
5816 }
5817 lay = FindLayout(buf);
5818 if (!lay)
5819 Msg(0, "No such layout\n");
5820 else if (lay == D_layout)
5821 Msg(0, "This IS layout %d (%s).\n", lay->lay_number, lay->lay_title);
5822 else
5823 {
5824 LoadLayout(lay, &D_canvas);
5825 Activate(0);
5826 }
5827 }
5828
5829
5830 static void
5831 InputSelect()
5832 {
5833 Input("Switch to window: ", 20, INP_COOKED, SelectFin, NULL, 0);
5834 }
5835
5836 static char setenv_var[31];
5837
5838
5839 static void
5840 SetenvFin1(buf, len, data)
5841 char *buf;
5842 int len;
5843 char *data; /* dummy */
5844 {
5845 if (!len || !display)
5846 return;
5847 InputSetenv(buf);
5848 }
5849
5850 static void
5851 SetenvFin2(buf, len, data)
5852 char *buf;
5853 int len;
5854 char *data; /* dummy */
5855 {
5856 if (!len || !display)
5857 return;
5858 debug2("SetenvFin2: setenv '%s' '%s'\n", setenv_var, buf);
5859 xsetenv(setenv_var, buf);
5860 MakeNewEnv();
5861 }
5862
5863 static void
5864 InputSetenv(arg)
5865 char *arg;
5866 {
5867 static char setenv_buf[50 + sizeof(setenv_var)]; /* need to be static here, cannot be freed */
5868
5869 if (arg)
5870 {
5871 strncpy(setenv_var, arg, sizeof(setenv_var) - 1);
5872 sprintf(setenv_buf, "Enter value for %s: ", setenv_var);
5873 Input(setenv_buf, 30, INP_COOKED, SetenvFin2, NULL, 0);
5874 }
5875 else
5876 Input("Setenv: Enter variable name: ", 30, INP_COOKED, SetenvFin1, NULL, 0);
5877 }
5878
5879 /*
5880 * the following options are understood by this parser:
5881 * -f, -f0, -f1, -fy, -fa
5882 * -t title, -T terminal-type, -h height-of-scrollback,
5883 * -ln, -l0, -ly, -l1, -l
5884 * -a, -M, -L
5885 */
5886 void
5887 DoScreen(fn, av)
5888 char *fn, **av;
5889 {
5890 struct NewWindow nwin;
5891 register int num;
5892 char buf[20];
5893
5894 nwin = nwin_undef;
5895 while (av && *av && av[0][0] == '-')
5896 {
5897 if (av[0][1] == '-')
5898 {
5899 av++;
5900 break;
5901 }
5902 switch (av[0][1])
5903 {
5904 case 'f':
5905 switch (av[0][2])
5906 {
5907 case 'n':
5908 case '0':
5909 nwin.flowflag = FLOW_NOW * 0;
5910 break;
5911 case 'y':
5912 case '1':
5913 case '\0':
5914 nwin.flowflag = FLOW_NOW * 1;
5915 break;
5916 case 'a':
5917 nwin.flowflag = FLOW_AUTOFLAG;
5918 break;
5919 default:
5920 break;
5921 }
5922 break;
5923 case 't': /* no more -k */
5924 if (av[0][2])
5925 nwin.aka = &av[0][2];
5926 else if (*++av)
5927 nwin.aka = *av;
5928 else
5929 --av;
5930 break;
5931 case 'T':
5932 if (av[0][2])
5933 nwin.term = &av[0][2];
5934 else if (*++av)
5935 nwin.term = *av;
5936 else
5937 --av;
5938 break;
5939 case 'h':
5940 if (av[0][2])
5941 nwin.histheight = atoi(av[0] + 2);
5942 else if (*++av)
5943 nwin.histheight = atoi(*av);
5944 else
5945 --av;
5946 break;
5947 #ifdef LOGOUTOK
5948 case 'l':
5949 switch (av[0][2])
5950 {
5951 case 'n':
5952 case '0':
5953 nwin.lflag = 0;
5954 break;
5955 case 'y':
5956 case '1':
5957 case '\0':
5958 nwin.lflag = 1;
5959 break;
5960 case 'a':
5961 nwin.lflag = 3;
5962 break;
5963 default:
5964 break;
5965 }
5966 break;
5967 #endif
5968 case 'a':
5969 nwin.aflag = 1;
5970 break;
5971 case 'M':
5972 nwin.monitor = MON_ON;
5973 break;
5974 case 'L':
5975 nwin.Lflag = 1;
5976 break;
5977 default:
5978 Msg(0, "%s: screen: invalid option -%c.", fn, av[0][1]);
5979 break;
5980 }
5981 ++av;
5982 }
5983 num = 0;
5984 if (av && *av && IsNumColon(*av, 10, buf, sizeof(buf)))
5985 {
5986 if (*buf != '\0')
5987 nwin.aka = buf;
5988 num = atoi(*av);
5989 if (num < 0 || num > MAXWIN - 1)
5990 {
5991 Msg(0, "%s: illegal screen number %d.", fn, num);
5992 num = 0;
5993 }
5994 nwin.StartAt = num;
5995 ++av;
5996 }
5997 if (av && *av)
5998 {
5999 nwin.args = av;
6000 if (!nwin.aka)
6001 nwin.aka = Filename(*av);
6002 }
6003 MakeWindow(&nwin);
6004 }
6005
6006 #ifdef COPY_PASTE
6007 /*
6008 * CompileKeys must be called before Markroutine is first used.
6009 * to initialise the keys with defaults, call CompileKeys(NULL, mark_key_tab);
6010 *
6011 * s is an ascii string in a termcap-like syntax. It looks like
6012 * "j=u:k=d:l=r:h=l: =.:" and so on...
6013 * this example rebinds the cursormovement to the keys u (up), d (down),
6014 * l (left), r (right). placing a mark will now be done with ".".
6015 */
6016 int
6017 CompileKeys(s, sl, array)
6018 char *s;
6019 int sl;
6020 unsigned char *array;
6021 {
6022 int i;
6023 unsigned char key, value;
6024
6025 if (sl == 0)
6026 {
6027 for (i = 0; i < 256; i++)
6028 array[i] = i;
6029 return 0;
6030 }
6031 debug1("CompileKeys: '%s'\n", s);
6032 while (sl)
6033 {
6034 key = *(unsigned char *)s++;
6035 if (*s != '=' || sl < 3)
6036 return -1;
6037 sl--;
6038 do
6039 {
6040 s++;
6041 sl -= 2;
6042 value = *(unsigned char *)s++;
6043 array[value] = key;
6044 }
6045 while (*s == '=' && sl >= 2);
6046 if (sl == 0)
6047 break;
6048 if (*s++ != ':')
6049 return -1;
6050 sl--;
6051 }
6052 return 0;
6053 }
6054 #endif /* COPY_PASTE */
6055
6056 /*
6057 * Asynchronous input functions
6058 */
6059
6060 #if defined(DETACH) && defined(POW_DETACH)
6061 static void
6062 pow_detach_fn(buf, len, data)
6063 char *buf;
6064 int len;
6065 char *data; /* dummy */
6066 {
6067 debug("pow_detach_fn called\n");
6068 if (len)
6069 {
6070 *buf = 0;
6071 return;
6072 }
6073 if (ktab[(int)(unsigned char)*buf].nr != RC_POW_DETACH)
6074 {
6075 if (display)
6076 write(D_userfd, "\007", 1);
6077 Msg(0, "Detach aborted.");
6078 }
6079 else
6080 Detach(D_POWER);
6081 }
6082 #endif /* POW_DETACH */
6083
6084 #ifdef COPY_PASTE
6085 static void
6086 copy_reg_fn(buf, len, data)
6087 char *buf;
6088 int len;
6089 char *data; /* dummy */
6090 {
6091 struct plop *pp = plop_tab + (int)(unsigned char)*buf;
6092
6093 if (len)
6094 {
6095 *buf = 0;
6096 return;
6097 }
6098 if (pp->buf)
6099 free(pp->buf);
6100 pp->buf = 0;
6101 pp->len = 0;
6102 if (D_user->u_plop.len)
6103 {
6104 if ((pp->buf = (char *)malloc(D_user->u_plop.len)) == NULL)
6105 {
6106 Msg(0, strnomem);
6107 return;
6108 }
6109 bcopy(D_user->u_plop.buf, pp->buf, D_user->u_plop.len);
6110 }
6111 pp->len = D_user->u_plop.len;
6112 #ifdef ENCODINGS
6113 pp->enc = D_user->u_plop.enc;
6114 #endif
6115 Msg(0, "Copied %d characters into register %c", D_user->u_plop.len, *buf);
6116 }
6117
6118 static void
6119 ins_reg_fn(buf, len, data)
6120 char *buf;
6121 int len;
6122 char *data; /* dummy */
6123 {
6124 struct plop *pp = plop_tab + (int)(unsigned char)*buf;
6125
6126 if (len)
6127 {
6128 *buf = 0;
6129 return;
6130 }
6131 if (!fore)
6132 return; /* Input() should not call us w/o fore, but you never know... */
6133 if (*buf == '.')
6134 Msg(0, "ins_reg_fn: Warning: pasting real register '.'!");
6135 if (pp->buf)
6136 {
6137 MakePaster(&fore->w_paster, pp->buf, pp->len, 0);
6138 return;
6139 }
6140 Msg(0, "Empty register.");
6141 }
6142 #endif /* COPY_PASTE */
6143
6144 static void
6145 process_fn(buf, len, data)
6146 char *buf;
6147 int len;
6148 char *data; /* dummy */
6149 {
6150 struct plop *pp = plop_tab + (int)(unsigned char)*buf;
6151
6152 if (len)
6153 {
6154 *buf = 0;
6155 return;
6156 }
6157 if (pp->buf)
6158 {
6159 ProcessInput(pp->buf, pp->len);
6160 return;
6161 }
6162 Msg(0, "Empty register.");
6163 }
6164
6165 static void
6166 confirm_fn(buf, len, data)
6167 char *buf;
6168 int len;
6169 char *data;
6170 {
6171 struct action act;
6172
6173 if (len || (*buf != 'y' && *buf != 'Y'))
6174 {
6175 *buf = 0;
6176 return;
6177 }
6178 act.nr = *(int *)data;
6179 act.args = noargs;
6180 act.argl = 0;
6181 DoAction(&act, -1);
6182 }
6183
6184 #ifdef MULTIUSER
6185 struct inputsu
6186 {
6187 struct acluser **up;
6188 char name[24];
6189 char pw1[130]; /* FreeBSD crypts to 128 bytes */
6190 char pw2[130];
6191 };
6192
6193 static void
6194 su_fin(buf, len, data)
6195 char *buf;
6196 int len;
6197 char *data;
6198 {
6199 struct inputsu *i = (struct inputsu *)data;
6200 char *p;
6201 int l;
6202
6203 if (!*i->name)
6204 { p = i->name; l = sizeof(i->name) - 1; }
6205 else if (!*i->pw1)
6206 { strcpy(p = i->pw1, "\377"); l = sizeof(i->pw1) - 1; }
6207 else
6208 { strcpy(p = i->pw2, "\377"); l = sizeof(i->pw2) - 1; }
6209 if (buf && len)
6210 strncpy(p, buf, 1 + (l < len) ? l : len);
6211 if (!*i->name)
6212 Input("Screen User: ", sizeof(i->name) - 1, INP_COOKED, su_fin, (char *)i, 0);
6213 else if (!*i->pw1)
6214 Input("User's UNIX Password: ", sizeof(i->pw1)-1, INP_COOKED|INP_NOECHO, su_fin, (char *)i, 0);
6215 else if (!*i->pw2)
6216 Input("User's Screen Password: ", sizeof(i->pw2)-1, INP_COOKED|INP_NOECHO, su_fin, (char *)i, 0);
6217 else
6218 {
6219 if ((p = DoSu(i->up, i->name, i->pw2, i->pw1)))
6220 Msg(0, "%s", p);
6221 free((char *)i);
6222 }
6223 }
6224
6225 static int
6226 InputSu(w, up, name)
6227 struct win *w;
6228 struct acluser **up;
6229 char *name;
6230 {
6231 struct inputsu *i;
6232
6233 if (!(i = (struct inputsu *)calloc(1, sizeof(struct inputsu))))
6234 return -1;
6235
6236 i->up = up;
6237 if (name && *name)
6238 su_fin(name, (int)strlen(name), (char *)i); /* can also initialise stuff */
6239 else
6240 su_fin((char *)0, 0, (char *)i);
6241 return 0;
6242 }
6243 #endif /* MULTIUSER */
6244
6245 #ifdef PASSWORD
6246
6247 static void
6248 pass1(buf, len, data)
6249 char *buf;
6250 int len;
6251 char *data;
6252 {
6253 struct acluser *u = (struct acluser *)data;
6254
6255 if (!*buf)
6256 return;
6257 ASSERT(u);
6258 if (u->u_password != NullStr)
6259 free((char *)u->u_password);
6260 u->u_password = SaveStr(buf);
6261 bzero(buf, strlen(buf));
6262 Input("Retype new password:", 100, INP_NOECHO, pass2, data, 0);
6263 }
6264
6265 static void
6266 pass2(buf, len, data)
6267 char *buf;
6268 int len;
6269 char *data;
6270 {
6271 int st;
6272 char salt[3];
6273 struct acluser *u = (struct acluser *)data;
6274
6275 ASSERT(u);
6276 if (!buf || strcmp(u->u_password, buf))
6277 {
6278 Msg(0, "[ Passwords don't match - checking turned off ]");
6279 if (u->u_password != NullStr)
6280 {
6281 bzero(u->u_password, strlen(u->u_password));
6282 free((char *)u->u_password);
6283 }
6284 u->u_password = NullStr;
6285 }
6286 else if (u->u_password[0] == '\0')
6287 {
6288 Msg(0, "[ No password - no secure ]");
6289 if (buf)
6290 bzero(buf, strlen(buf));
6291 }
6292
6293 if (u->u_password != NullStr)
6294 {
6295 for (st = 0; st < 2; st++)
6296 salt[st] = 'A' + (int)((time(0) >> 6 * st) % 26);
6297 salt[2] = 0;
6298 buf = crypt(u->u_password, salt);
6299 bzero(u->u_password, strlen(u->u_password));
6300 free((char *)u->u_password);
6301 u->u_password = SaveStr(buf);
6302 bzero(buf, strlen(buf));
6303 #ifdef COPY_PASTE
6304 if (u->u_plop.buf)
6305 UserFreeCopyBuffer(u);
6306 u->u_plop.len = strlen(u->u_password);
6307 # ifdef ENCODINGS
6308 u->u_plop.enc = 0;
6309 #endif
6310 if (!(u->u_plop.buf = SaveStr(u->u_password)))
6311 {
6312 Msg(0, strnomem);
6313 D_user->u_plop.len = 0;
6314 }
6315 else
6316 Msg(0, "[ Password moved into copybuffer ]");
6317 #else /* COPY_PASTE */
6318 Msg(0, "[ Crypted password is \"%s\" ]", u->u_password);
6319 #endif /* COPY_PASTE */
6320 }
6321 }
6322 #endif /* PASSWORD */
6323
6324 static int
6325 digraph_find(buf)
6326 const char *buf;
6327 {
6328 int i;
6329 for (i = 0; i < MAX_DIGRAPH && digraphs[i].d[0]; i++)
6330 if ((digraphs[i].d[0] == (unsigned char)buf[0] && digraphs[i].d[1] == (unsigned char)buf[1]) ||
6331 (digraphs[i].d[0] == (unsigned char)buf[1] && digraphs[i].d[1] == (unsigned char)buf[0]))
6332 break;
6333 return i;
6334 }
6335
6336 static void
6337 digraph_fn(buf, len, data)
6338 char *buf;
6339 int len;
6340 char *data; /* dummy */
6341 {
6342 int ch, i, x;
6343
6344 ch = buf[len];
6345 if (ch)
6346 {
6347 buf[len + 1] = ch; /* so we can restore it later */
6348 if (ch < ' ' || ch == '\177')
6349 return;
6350 if (len >= 1 && ((*buf == 'U' && buf[1] == '+') || (*buf == '0' && (buf[1] == 'x' || buf[1] == 'X'))))
6351 {
6352 if (len == 1)
6353 return;
6354 if ((ch < '0' || ch > '9') && (ch < 'a' || ch > 'f') && (ch < 'A' || ch > 'F'))
6355 {
6356 buf[len] = '\034'; /* ^] is ignored by Input() */
6357 return;
6358 }
6359 if (len == (*buf == 'U' ? 5 : 3))
6360 buf[len] = '\n';
6361 return;
6362 }
6363 if (len && *buf == '0')
6364 {
6365 if (ch < '0' || ch > '7')
6366 {
6367 buf[len] = '\034'; /* ^] is ignored by Input() */
6368 return;
6369 }
6370 if (len == 3)
6371 buf[len] = '\n';
6372 return;
6373 }
6374 if (len == 1)
6375 buf[len] = '\n';
6376 return;
6377 }
6378 if (len < 1)
6379 return;
6380 if (buf[len + 1])
6381 {
6382 buf[len] = buf[len + 1]; /* stored above */
6383 len++;
6384 }
6385 if (len < 2)
6386 return;
6387 if (!parse_input_int(buf, len, &x))
6388 {
6389 i = digraph_find(buf);
6390 if ((x = digraphs[i].value) <= 0)
6391 {
6392 Msg(0, "Unknown digraph");
6393 return;
6394 }
6395 }
6396 i = 1;
6397 *buf = x;
6398 #ifdef UTF8
6399 if (flayer->l_encoding == UTF8)
6400 i = ToUtf8(buf, x); /* buf is big enough for all UTF-8 codes */
6401 #endif
6402 while(i)
6403 LayProcess(&buf, &i);
6404 }
6405
6406 #ifdef MAPKEYS
6407 int
6408 StuffKey(i)
6409 int i;
6410 {
6411 struct action *act;
6412 int discard = 0;
6413
6414 debug1("StuffKey #%d", i);
6415 #ifdef DEBUG
6416 if (i < KMAP_KEYS)
6417 debug1(" - %s", term[i + T_CAPS].tcname);
6418 #endif
6419
6420 if (i < KMAP_KEYS && D_ESCseen)
6421 {
6422 struct action *act = &D_ESCseen[i + 256];
6423 if (act->nr != RC_ILLEGAL)
6424 {
6425 D_ESCseen = 0;
6426 DoAction(act, i + 256);
6427 return 0;
6428 }
6429 discard = 1;
6430 }
6431
6432 if (i >= T_CURSOR - T_CAPS && i < T_KEYPAD - T_CAPS && D_cursorkeys)
6433 i += T_OCAPS - T_CURSOR;
6434 else if (i >= T_KEYPAD - T_CAPS && i < T_OCAPS - T_CAPS && D_keypad)
6435 i += T_OCAPS - T_CURSOR;
6436 debug1(" - action %d\n", i);
6437 flayer = D_forecv->c_layer;
6438 fore = D_fore;
6439 act = 0;
6440 #ifdef COPY_PASTE
6441 if (InMark() || InInput() || InWList())
6442 act = i < KMAP_KEYS+KMAP_AKEYS ? &mmtab[i] : &kmap_exts[i - (KMAP_KEYS+KMAP_AKEYS)].mm;
6443 #endif
6444 if ((!act || act->nr == RC_ILLEGAL) && !D_mapdefault)
6445 act = i < KMAP_KEYS+KMAP_AKEYS ? &umtab[i] : &kmap_exts[i - (KMAP_KEYS+KMAP_AKEYS)].um;
6446 if (!act || act->nr == RC_ILLEGAL)
6447 act = i < KMAP_KEYS+KMAP_AKEYS ? &dmtab[i] : &kmap_exts[i - (KMAP_KEYS+KMAP_AKEYS)].dm;
6448
6449 if (discard && (!act || act->nr != RC_COMMAND))
6450 {
6451 D_ESCseen = 0;
6452 return 0;
6453 }
6454 D_mapdefault = 0;
6455
6456 if (act == 0 || act->nr == RC_ILLEGAL)
6457 return -1;
6458 DoAction(act, 0);
6459 return 0;
6460 }
6461 #endif
6462
6463
6464 static int
6465 IsOnDisplay(wi)
6466 struct win *wi;
6467 {
6468 struct canvas *cv;
6469 ASSERT(display);
6470 for (cv = D_cvlist; cv; cv = cv->c_next)
6471 if (Layer2Window(cv->c_layer) == wi)
6472 return 1;
6473 return 0;
6474 }
6475
6476 struct win *
6477 FindNiceWindow(wi, presel)
6478 struct win *wi;
6479 char *presel;
6480 {
6481 int i;
6482
6483 debug2("FindNiceWindow %d %s\n", wi ? wi->w_number : -1 , presel ? presel : "NULL");
6484 if (presel)
6485 {
6486 i = WindowByNoN(presel);
6487 if (i >= 0)
6488 wi = wtab[i];
6489 }
6490 if (!display)
6491 return wi;
6492 #ifdef MULTIUSER
6493 if (wi && AclCheckPermWin(D_user, ACL_READ, wi))
6494 wi = 0;
6495 #endif
6496 if (!wi || (IsOnDisplay(wi) && !presel))
6497 {
6498 /* try to get another window */
6499 wi = 0;
6500 #ifdef MULTIUSER
6501 for (wi = windows; wi; wi = wi->w_next)
6502 if (!wi->w_layer.l_cvlist && !AclCheckPermWin(D_user, ACL_WRITE, wi))
6503 break;
6504 if (!wi)
6505 for (wi = windows; wi; wi = wi->w_next)
6506 if (wi->w_layer.l_cvlist && !IsOnDisplay(wi) && !AclCheckPermWin(D_user, ACL_WRITE, wi))
6507 break;
6508 if (!wi)
6509 for (wi = windows; wi; wi = wi->w_next)
6510 if (!wi->w_layer.l_cvlist && !AclCheckPermWin(D_user, ACL_READ, wi))
6511 break;
6512 if (!wi)
6513 for (wi = windows; wi; wi = wi->w_next)
6514 if (wi->w_layer.l_cvlist && !IsOnDisplay(wi) && !AclCheckPermWin(D_user, ACL_READ, wi))
6515 break;
6516 #endif
6517 if (!wi)
6518 for (wi = windows; wi; wi = wi->w_next)
6519 if (!wi->w_layer.l_cvlist)
6520 break;
6521 if (!wi)
6522 for (wi = windows; wi; wi = wi->w_next)
6523 if (wi->w_layer.l_cvlist && !IsOnDisplay(wi))
6524 break;
6525 }
6526 #ifdef MULTIUSER
6527 if (wi && AclCheckPermWin(D_user, ACL_READ, wi))
6528 wi = 0;
6529 #endif
6530 return wi;
6531 }
6532
6533 #if 0
6534
6535 /* sorted list of all commands */
6536 static struct comm **commtab;
6537 static int ncommtab;
6538
6539 void
6540 AddComms(cos, hand)
6541 struct comm *cos;
6542 void (*hand) __P((struct comm *, char **, int));
6543 {
6544 int n, i, j, r;
6545 for (n = 0; cos[n].name; n++)
6546 ;
6547 if (n == 0)
6548 return;
6549 if (commtab)
6550 commtab = (struct commt *)realloc(commtab, sizeof(*commtab) * (ncommtab + n));
6551 else
6552 commtab = (struct commt *)malloc(sizeof(*commtab) * (ncommtab + n));
6553 if (!commtab)
6554 Panic(0, strnomem);
6555 for (i = 0; i < n; i++)
6556 {
6557 for (j = 0; j < ncommtab; j++)
6558 {
6559 r = strcmp(cos[i].name, commtab[j]->name);
6560 if (r == 0)
6561 Panic(0, "Duplicate command: %s\n", cos[i].name);
6562 if (r < 0)
6563 break;
6564 }
6565 for (r = ncommtab; r > j; r--)
6566 commtab[r] = commtab[r - 1];
6567 commtab[j] = cos + i;
6568 cos[i].handler = hand;
6569 bzero(cos[i].userbits, sizeof(cos[i].userbits));
6570 ncommtab++;
6571 }
6572 }
6573
6574 struct comm *
6575 FindComm(str)
6576 char *str;
6577 {
6578 int x, m, l = 0, r = ncommtab - 1;
6579 while (l <= r)
6580 {
6581 m = (l + r) / 2;
6582 x = strcmp(str, commtab[m]->name);
6583 if (x > 0)
6584 l = m + 1;
6585 else if (x < 0)
6586 r = m - 1;
6587 else
6588 return commtab[m];
6589 }
6590 return 0;
6591 }
6592
6593 #endif
6594
6595 static int
6596 CalcSlicePercent(cv, percent)
6597 struct canvas *cv;
6598 int percent;
6599 {
6600 int w, wsum, up;
6601 if (!cv || !cv->c_slback)
6602 return percent;
6603 up = CalcSlicePercent(cv->c_slback->c_slback, percent);
6604 w = cv->c_slweight;
6605 for (cv = cv->c_slback->c_slperp, wsum = 0; cv; cv = cv->c_slnext)
6606 wsum += cv->c_slweight;
6607 if (wsum == 0)
6608 return 0;
6609 return (up * w) / wsum;
6610 }
6611
6612 static int
6613 ChangeCanvasSize(fcv, abs, diff, gflag, percent)
6614 struct canvas *fcv; /* make this canvas bigger */
6615 int abs; /* mode: 0:rel 1:abs 2:max */
6616 int diff; /* change this much */
6617 int gflag; /* go up if neccessary */
6618 int percent;
6619 {
6620 struct canvas *cv;
6621 int done, have, m, dir;
6622
6623 debug3("ChangeCanvasSize abs %d diff %d percent=%d\n", abs, diff, percent);
6624 if (abs == 0 && diff == 0)
6625 return 0;
6626 if (abs == 2)
6627 {
6628 if (diff == 0)
6629 fcv->c_slweight = 0;
6630 else
6631 {
6632 for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext)
6633 cv->c_slweight = 0;
6634 fcv->c_slweight = 1;
6635 cv = fcv->c_slback->c_slback;
6636 if (gflag && cv && cv->c_slback)
6637 ChangeCanvasSize(cv, abs, diff, gflag, percent);
6638 }
6639 return diff;
6640 }
6641 if (abs)
6642 {
6643 if (diff < 0)
6644 diff = 0;
6645 if (percent && diff > percent)
6646 diff = percent;
6647 }
6648 if (percent)
6649 {
6650 int wsum, up;
6651 for (cv = fcv->c_slback->c_slperp, wsum = 0; cv; cv = cv->c_slnext)
6652 wsum += cv->c_slweight;
6653 if (wsum)
6654 {
6655 up = gflag ? CalcSlicePercent(fcv->c_slback->c_slback, percent) : percent;
6656 debug3("up=%d, wsum=%d percent=%d\n", up, wsum, percent);
6657 if (wsum < 1000)
6658 {
6659 int scale = wsum < 10 ? 1000 : 100;
6660 for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext)
6661 cv->c_slweight *= scale;
6662 wsum *= scale;
6663 debug1("scaled wsum to %d\n", wsum);
6664 }
6665 for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext)
6666 {
6667 if (cv->c_slweight)
6668 {
6669 cv->c_slweight = (cv->c_slweight * up) / percent;
6670 if (cv->c_slweight == 0)
6671 cv->c_slweight = 1;
6672 }
6673 debug1(" - weight %d\n", cv->c_slweight);
6674 }
6675 diff = (diff * wsum) / percent;
6676 percent = wsum;
6677 }
6678 }
6679 else
6680 {
6681 if (abs && diff == (fcv->c_slorient == SLICE_VERT ? fcv->c_ye - fcv->c_ys + 2 : fcv->c_xe - fcv->c_xs + 2))
6682 return 0;
6683 /* fix weights to real size (can't be helped, sorry) */
6684 for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext)
6685 {
6686 cv->c_slweight = cv->c_slorient == SLICE_VERT ? cv->c_ye - cv->c_ys + 2 : cv->c_xe - cv->c_xs + 2;
6687 debug1(" - weight %d\n", cv->c_slweight);
6688 }
6689 }
6690 if (abs)
6691 diff = diff - fcv->c_slweight;
6692 debug1("diff = %d\n", diff);
6693 if (diff == 0)
6694 return 0;
6695 if (diff < 0)
6696 {
6697 cv = fcv->c_slnext ? fcv->c_slnext : fcv->c_slprev;
6698 fcv->c_slweight += diff;
6699 cv->c_slweight -= diff;
6700 return diff;
6701 }
6702 done = 0;
6703 dir = 1;
6704 for (cv = fcv->c_slnext; diff > 0; cv = dir > 0 ? cv->c_slnext : cv->c_slprev)
6705 {
6706 if (!cv)
6707 {
6708 debug1("reached end, dir is %d\n", dir);
6709 if (dir == -1)
6710 break;
6711 dir = -1;
6712 cv = fcv;
6713 continue;
6714 }
6715 if (percent)
6716 m = 1;
6717 else
6718 m = cv->c_slperp ? CountCanvasPerp(cv) * 2 : 2;
6719 debug2("min is %d, have %d\n", m, cv->c_slweight);
6720 if (cv->c_slweight > m)
6721 {
6722 have = cv->c_slweight - m;
6723 if (have > diff)
6724 have = diff;
6725 debug1("subtract %d\n", have);
6726 cv->c_slweight -= have;
6727 done += have;
6728 diff -= have;
6729 }
6730 }
6731 if (diff && gflag)
6732 {
6733 /* need more room! */
6734 cv = fcv->c_slback->c_slback;
6735 if (cv && cv->c_slback)
6736 done += ChangeCanvasSize(fcv->c_slback->c_slback, 0, diff, gflag, percent);
6737 }
6738 fcv->c_slweight += done;
6739 debug1("ChangeCanvasSize returns %d\n", done);
6740 return done;
6741 }
6742
6743 static void
6744 ResizeRegions(arg, flags)
6745 char *arg;
6746 int flags;
6747 {
6748 struct canvas *cv;
6749 int diff, l;
6750 int gflag = 0, abs = 0, percent = 0;
6751 int orient = 0;
6752
6753 ASSERT(display);
6754 if (!*arg)
6755 return;
6756 if (D_forecv->c_slorient == SLICE_UNKN)
6757 {
6758 Msg(0, "resize: need more than one region");
6759 return;
6760 }
6761 gflag = flags & RESIZE_FLAG_L ? 0 : 1;
6762 orient |= flags & RESIZE_FLAG_H ? SLICE_HORI : 0;
6763 orient |= flags & RESIZE_FLAG_V ? SLICE_VERT : 0;
6764 if (orient == 0)
6765 orient = D_forecv->c_slorient;
6766 l = strlen(arg);
6767 if (*arg == '=')
6768 {
6769 /* make all regions the same height */
6770 struct canvas *cv = gflag ? &D_canvas : D_forecv->c_slback;
6771 if (cv->c_slperp->c_slorient & orient)
6772 EqualizeCanvas(cv->c_slperp, gflag);
6773 /* can't use cv->c_slorient directly as it can be D_canvas */
6774 if ((cv->c_slperp->c_slorient ^ (SLICE_HORI ^ SLICE_VERT)) & orient)
6775 {
6776 if (cv->c_slback)
6777 {
6778 cv = cv->c_slback;
6779 EqualizeCanvas(cv->c_slperp, gflag);
6780 }
6781 else
6782 EqualizeCanvas(cv, gflag);
6783 }
6784 ResizeCanvas(cv);
6785 RecreateCanvasChain();
6786 RethinkDisplayViewports();
6787 ResizeLayersToCanvases();
6788 return;
6789 }
6790 if (!strcmp(arg, "min") || !strcmp(arg, "0"))
6791 {
6792 abs = 2;
6793 diff = 0;
6794 }
6795 else if (!strcmp(arg, "max") || !strcmp(arg, "_"))
6796 {
6797 abs = 2;
6798 diff = 1;
6799 }
6800 else
6801 {
6802 if (l > 0 && arg[l - 1] == '%')
6803 percent = 1000;
6804 if (*arg == '+')
6805 diff = atoi(arg + 1);
6806 else if (*arg == '-')
6807 diff = -atoi(arg + 1);
6808 else
6809 {
6810 diff = atoi(arg); /* +1 because of caption line */
6811 if (diff < 0)
6812 diff = 0;
6813 abs = diff == 0 ? 2 : 1;
6814 }
6815 }
6816 if (!abs && !diff)
6817 return;
6818 if (percent)
6819 diff = diff * percent / 100;
6820 cv = D_forecv;
6821 if (cv->c_slorient & orient)
6822 ChangeCanvasSize(cv, abs, diff, gflag, percent);
6823 if (cv->c_slback->c_slorient & orient)
6824 ChangeCanvasSize(cv->c_slback, abs, diff, gflag, percent);
6825
6826 ResizeCanvas(&D_canvas);
6827 RecreateCanvasChain();
6828 RethinkDisplayViewports();
6829 ResizeLayersToCanvases();
6830 return;
6831
6832 #if 0
6833
6834 if (siz + diff < 1)
6835 diff = 1 - siz;
6836 if (siz + diff > dsize - (nreg - 1) * 2 - 1)
6837 diff = dsize - (nreg - 1) * 2 - 1 - siz;
6838 if (diff == 0 || siz + diff < 1)
6839 return;
6840
6841 if (diff < 0)
6842 {
6843 if (D_forecv->c_next)
6844 {
6845 D_forecv->c_ye += diff;
6846 D_forecv->c_next->c_ys += diff;
6847 D_forecv->c_next->c_yoff += diff;
6848 }
6849 else
6850 {
6851 for (cv = D_cvlist; cv; cv = cv->c_next)
6852 if (cv->c_next == D_forecv)
6853 break;
6854 ASSERT(cv);
6855 cv->c_ye -= diff;
6856 D_forecv->c_ys -= diff;
6857 D_forecv->c_yoff -= diff;
6858 }
6859 }
6860 else
6861 {
6862 int s, i = 0, found = 0, di = diff, d2;
6863 s = dsize - (nreg - 1) * 2 - 1 - siz;
6864 for (cv = D_cvlist; cv; i = cv->c_ye + 2, cv = cv->c_next)
6865 {
6866 if (cv == D_forecv)
6867 {
6868 cv->c_ye = i + (cv->c_ye - cv->c_ys) + diff;
6869 cv->c_yoff -= cv->c_ys - i;
6870 cv->c_ys = i;
6871 found = 1;
6872 continue;
6873 }
6874 s -= cv->c_ye - cv->c_ys;
6875 if (!found)
6876 {
6877 if (s >= di)
6878 continue;
6879 d2 = di - s;
6880 }
6881 else
6882 d2 = di > cv->c_ye - cv->c_ys ? cv->c_ye - cv->c_ys : di;
6883 di -= d2;
6884 cv->c_ye = i + (cv->c_ye - cv->c_ys) - d2;
6885 cv->c_yoff -= cv->c_ys - i;
6886 cv->c_ys = i;
6887 }
6888 }
6889 RethinkDisplayViewports();
6890 ResizeLayersToCanvases();
6891 #endif
6892 }
6893
6894 static void
6895 ResizeFin(buf, len, data)
6896 char *buf;
6897 int len;
6898 char *data;
6899 {
6900 int ch;
6901 int flags = *(int *)data;
6902 ch = ((unsigned char *)buf)[len];
6903 if (ch == 0)
6904 {
6905 ResizeRegions(buf, flags);
6906 return;
6907 }
6908 if (ch == 'h')
6909 flags ^= RESIZE_FLAG_H;
6910 else if (ch == 'v')
6911 flags ^= RESIZE_FLAG_V;
6912 else if (ch == 'b')
6913 flags |= RESIZE_FLAG_H|RESIZE_FLAG_V;
6914 else if (ch == 'p')
6915 flags ^= D_forecv->c_slorient == SLICE_VERT ? RESIZE_FLAG_H : RESIZE_FLAG_V;
6916 else if (ch == 'l')
6917 flags ^= RESIZE_FLAG_L;
6918 else
6919 return;
6920 inp_setprompt(resizeprompts[flags], NULL);
6921 *(int *)data = flags;
6922 buf[len] = '\034';
6923 }
6924
6925 #ifdef RXVT_OSC
6926 void
6927 RefreshXtermOSC()
6928 {
6929 int i;
6930 struct win *p;
6931
6932 p = Layer2Window(D_forecv->c_layer);
6933 for (i = 3; i >=0; i--)
6934 SetXtermOSC(i, p ? p->w_xtermosc[i] : 0);
6935 }
6936 #endif
6937
6938 int
6939 ParseAttrColor(s1, s2, msgok)
6940 char *s1, *s2;
6941 int msgok;
6942 {
6943 int i, n;
6944 char *s, *ss;
6945 int r = 0;
6946
6947 s = s1;
6948 while (*s == ' ')
6949 s++;
6950 ss = s;
6951 while (*ss && *ss != ' ')
6952 ss++;
6953 while (*ss == ' ')
6954 ss++;
6955 if (*s && (s2 || *ss || !((*s >= 'a' && *s <= 'z') || (*s >= 'A' && *s <= 'Z') || *s == '.')))
6956 {
6957 int mode = 0, n = 0;
6958 if (*s == '+')
6959 {
6960 mode = 1;
6961 s++;
6962 }
6963 else if (*s == '-')
6964 {
6965 mode = -1;
6966 s++;
6967 }
6968 else if (*s == '!')
6969 {
6970 mode = 2;
6971 s++;
6972 }
6973 else if (*s == '=')
6974 s++;
6975 if (*s >= '0' && *s <= '9')
6976 {
6977 n = *s++ - '0';
6978 if (*s >= '0' && *s <= '9')
6979 n = n * 16 + (*s++ - '0');
6980 else if (*s >= 'a' && *s <= 'f')
6981 n = n * 16 + (*s++ - ('a' - 10));
6982 else if (*s >= 'A' && *s <= 'F')
6983 n = n * 16 + (*s++ - ('A' - 10));
6984 else if (*s && *s != ' ')
6985 {
6986 if (msgok)
6987 Msg(0, "Illegal attribute hexchar '%c'", *s);
6988 return -1;
6989 }
6990 }
6991 else
6992 {
6993 while (*s && *s != ' ')
6994 {
6995 if (*s == 'd')
6996 n |= A_DI;
6997 else if (*s == 'u')
6998 n |= A_US;
6999 else if (*s == 'b')
7000 n |= A_BD;
7001 else if (*s == 'r')
7002 n |= A_RV;
7003 else if (*s == 's')
7004 n |= A_SO;
7005 else if (*s == 'B')
7006 n |= A_BL;
7007 else
7008 {
7009 if (msgok)
7010 Msg(0, "Illegal attribute specifier '%c'", *s);
7011 return -1;
7012 }
7013 s++;
7014 }
7015 }
7016 if (*s && *s != ' ')
7017 {
7018 if (msgok)
7019 Msg(0, "junk after attribute description: '%c'", *s);
7020 return -1;
7021 }
7022 if (mode == -1)
7023 r = n << 8 | n;
7024 else if (mode == 1)
7025 r = n << 8;
7026 else if (mode == 2)
7027 r = n;
7028 else if (mode == 0)
7029 r = 0xffff ^ n;
7030 }
7031 while (*s && *s == ' ')
7032 s++;
7033
7034 if (s2)
7035 {
7036 if (*s)
7037 {
7038 if (msgok)
7039 Msg(0, "junk after description: '%c'", *s);
7040 return -1;
7041 }
7042 s = s2;
7043 while (*s && *s == ' ')
7044 s++;
7045 }
7046
7047 #ifdef COLOR
7048 if (*s)
7049 {
7050 static char costr[] = "krgybmcw d i.01234567 9 f FKRGYBMCW I ";
7051 int numco = 0, j;
7052
7053 n = 0;
7054 if (*s == '.')
7055 {
7056 numco++;
7057 n = 0x0f;
7058 s++;
7059 }
7060 for (j = 0; j < 2 && *s && *s != ' '; j++)
7061 {
7062 for (i = 0; costr[i]; i++)
7063 if (*s == costr[i])
7064 break;
7065 if (!costr[i])
7066 {
7067 if (msgok)
7068 Msg(0, "illegal color descriptor: '%c'", *s);
7069 return -1;
7070 }
7071 numco++;
7072 n = n << 4 | (i & 15);
7073 #ifdef COLORS16
7074 if (i >= 48)
7075 n = (n & 0x20ff) | 0x200;
7076 #endif
7077 s++;
7078 }
7079 if ((n & 0xf00) == 0xf00)
7080 n ^= 0xf00; /* clear superflous bits */
7081 #ifdef COLORS16
7082 if (n & 0x2000)
7083 n ^= 0x2400; /* shift bit into right position */
7084 #endif
7085 if (numco == 1)
7086 n |= 0xf0; /* don't change bg color */
7087 if (numco != 2 && n != 0xff)
7088 n |= 0x100; /* special invert mode */
7089 if (*s && *s != ' ')
7090 {
7091 if (msgok)
7092 Msg(0, "junk after color description: '%c'", *s);
7093 return -1;
7094 }
7095 n ^= 0xff;
7096 r |= n << 16;
7097 }
7098 #endif
7099
7100 while (*s && *s == ' ')
7101 s++;
7102 if (*s)
7103 {
7104 if (msgok)
7105 Msg(0, "junk after description: '%c'", *s);
7106 return -1;
7107 }
7108 debug1("ParseAttrColor %06x\n", r);
7109 return r;
7110 }
7111
7112 /*
7113 * Color coding:
7114 * 0-7 normal colors
7115 * 9 default color
7116 * e just set intensity
7117 * f don't change anything
7118 * Intensity is encoded into bits 17(fg) and 18(bg).
7119 */
7120 void
7121 ApplyAttrColor(i, mc)
7122 int i;
7123 struct mchar *mc;
7124 {
7125 debug1("ApplyAttrColor %06x\n", i);
7126 mc->attr |= i >> 8 & 255;
7127 mc->attr ^= i & 255;
7128 #ifdef COLOR
7129 i = (i >> 16) ^ 0xff;
7130 if ((i & 0x100) != 0)
7131 {
7132 i &= 0xeff;
7133 if (mc->attr & (A_SO|A_RV))
7134 # ifdef COLORS16
7135 i = ((i & 0x0f) << 4) | ((i & 0xf0) >> 4) | ((i & 0x200) << 1) | ((i & 0x400) >> 1);
7136 # else
7137 i = ((i & 0x0f) << 4) | ((i & 0xf0) >> 4);
7138 # endif
7139 }
7140 # ifdef COLORS16
7141 if ((i & 0x0f) != 0x0f)
7142 mc->attr = (mc->attr & 0xbf) | ((i >> 3) & 0x40);
7143 if ((i & 0xf0) != 0xf0)
7144 mc->attr = (mc->attr & 0x7f) | ((i >> 3) & 0x80);
7145 # endif
7146 mc->color = 0x99 ^ mc->color;
7147 if ((i & 0x0e) == 0x0e)
7148 i = (i & 0xf0) | (mc->color & 0x0f);
7149 if ((i & 0xe0) == 0xe0)
7150 i = (i & 0x0f) | (mc->color & 0xf0);
7151 mc->color = 0x99 ^ i;
7152 debug2("ApplyAttrColor - %02x %02x\n", mc->attr, i);
7153 #endif
7154 }
Lua scripting support for GNU Screen