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