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