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