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