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