?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Nested list of windows in the windowlist view
[screen-lua.git] / src / process.c
blob4d1460a67870948290c550a5fcd043e7d0b9e244
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, "string"))
2082 {
2083 if (args[1])
2084 {
2085 if (wliststr)
2086 free(wliststr);
2087 wliststr = SaveStr(args[1]);
2088 }
2089 if (msgok)
2090 Msg(0, "windowlist string is '%s'", wliststr);
2091 }
2092 else if (!strcmp(*args, "title"))
2093 {
2094 if (args[1])
2095 {
2096 if (wlisttit)
2097 free(wlisttit);
2098 wlisttit = SaveStr(args[1]);
2099 }
2100 if (msgok)
2101 Msg(0, "windowlist title is '%s'", wlisttit);
2102 }
2103 else
2104 {
2105 int flag = 0;
2106 int blank = 0;
2107 for (i = 0; i < argc; i++)
2108 if (!args[i])
2109 continue;
2110 else if (!strcmp(args[i], "-m"))
2111 flag |= WLIST_MRU;
2112 else if (!strcmp(args[i], "-b"))
2113 blank = 1;
2114 else if (!strcmp(args[i], "-g"))
2115 flag |= WLIST_NESTED;
2116 else
2117 {
2118 Msg(0, "usage: windowlist [-b] [string [string] | title [title]]");
2119 break;
2120 }
2121 if (i == argc)
2122 display_wlist(blank, flag, (struct win *)0);
2123 }
2124 break;
2125 case RC_HELP:
2126 if (argc == 2 && !strcmp(*args, "-c"))
2127 {
2128 struct action *ktabp;
2129 if ((ktabp = FindKtab(args[1], 0)) == 0)
2130 {
2131 Msg(0, "Unknown command class '%s'", args[1]);
2132 break;
2133 }
2134 display_help(args[1], ktabp);
2135 }
2136 else
2137 display_help((char *)0, ktab);
2138 break;
2139 case RC_LICENSE:
2140 display_copyright();
2141 break;
2142 #ifdef COPY_PASTE
2143 case RC_COPY:
2144 if (flayer->l_layfn != &WinLf)
2145 {
2146 Msg(0, "Must be on a window layer");
2147 break;
2148 }
2149 MarkRoutine();
2150 break;
2151 case RC_HISTORY:
2152 {
2153 static char *pasteargs[] = {".", 0};
2154 static int pasteargl[] = {1};
2155
2156 if (flayer->l_layfn != &WinLf)
2157 {
2158 Msg(0, "Must be on a window layer");
2159 break;
2160 }
2161 if (GetHistory() == 0)
2162 break;
2163 if (user->u_plop.buf == NULL)
2164 break;
2165 args = pasteargs;
2166 argl = pasteargl;
2167 }
2168 /*FALLTHROUGH*/
2169 case RC_PASTE:
2170 {
2171 char *ss, *dbuf, dch;
2172 int l = 0;
2173 # ifdef ENCODINGS
2174 int enc = -1;
2175 # endif
2176
2177 /*
2178 * without args we prompt for one(!) register to be pasted in the window
2179 */
2180 if ((s = *args) == NULL)
2181 {
2182 Input("Paste from register:", 1, INP_RAW, ins_reg_fn, NULL, 0);
2183 break;
2184 }
2185 if (args[1] == 0 && !fore) /* no window? */
2186 break;
2187 /*
2188 * with two arguments we paste into a destination register
2189 * (no window needed here).
2190 */
2191 if (args[1] && argl[1] != 1)
2192 {
2193 Msg(0, "%s: paste destination: character, ^x, or (octal) \\032 expected.",
2194 rc_name);
2195 break;
2196 }
2197 # ifdef ENCODINGS
2198 else if (fore)
2199 enc = fore->w_encoding;
2200 # endif
2201
2202 /*
2203 * measure length of needed buffer
2204 */
2205 for (ss = s = *args; (ch = *ss); ss++)
2206 {
2207 if (ch == '.')
2208 {
2209 # ifdef ENCODINGS
2210 if (enc == -1)
2211 enc = user->u_plop.enc;
2212 if (enc != user->u_plop.enc)
2213 l += RecodeBuf((unsigned char *)user->u_plop.buf, user->u_plop.len, user->u_plop.enc, enc, (unsigned char *)0);
2214 else
2215 # endif
2216 l += user->u_plop.len;
2217 }
2218 else
2219 {
2220 # ifdef ENCODINGS
2221 if (enc == -1)
2222 enc = plop_tab[(int)(unsigned char)ch].enc;
2223 if (enc != plop_tab[(int)(unsigned char)ch].enc)
2224 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);
2225 else
2226 # endif
2227 l += plop_tab[(int)(unsigned char)ch].len;
2228 }
2229 }
2230 if (l == 0)
2231 {
2232 Msg(0, "empty buffer");
2233 break;
2234 }
2235 /*
2236 * shortcut:
2237 * if there is only one source and the destination is a window, then
2238 * pass a pointer rather than duplicating the buffer.
2239 */
2240 if (s[1] == 0 && args[1] == 0)
2241 # ifdef ENCODINGS
2242 if (enc == (*s == '.' ? user->u_plop.enc : plop_tab[(int)(unsigned char)*s].enc))
2243 # endif
2244 {
2245 MakePaster(&fore->w_paster, *s == '.' ? user->u_plop.buf : plop_tab[(int)(unsigned char)*s].buf, l, 0);
2246 break;
2247 }
2248 /*
2249 * if no shortcut, we construct a buffer
2250 */
2251 if ((dbuf = (char *)malloc(l)) == 0)
2252 {
2253 Msg(0, strnomem);
2254 break;
2255 }
2256 l = 0;
2257 /*
2258 * concatenate all sources into our own buffer, copy buffer is
2259 * special and is skipped if no display exists.
2260 */
2261 for (ss = s; (ch = *ss); ss++)
2262 {
2263 struct plop *pp = (ch == '.' ? &user->u_plop : &plop_tab[(int)(unsigned char)ch]);
2264 #ifdef ENCODINGS
2265 if (pp->enc != enc)
2266 {
2267 l += RecodeBuf((unsigned char *)pp->buf, pp->len, pp->enc, enc, (unsigned char *)dbuf + l);
2268 continue;
2269 }
2270 #endif
2271 bcopy(pp->buf, dbuf + l, pp->len);
2272 l += pp->len;
2273 }
2274 /*
2275 * when called with one argument we paste our buffer into the window
2276 */
2277 if (args[1] == 0)
2278 {
2279 MakePaster(&fore->w_paster, dbuf, l, 1);
2280 }
2281 else
2282 {
2283 /*
2284 * we have two arguments, the second is already in dch.
2285 * use this as destination rather than the window.
2286 */
2287 dch = args[1][0];
2288 if (dch == '.')
2289 {
2290 if (user->u_plop.buf != NULL)
2291 UserFreeCopyBuffer(user);
2292 user->u_plop.buf = dbuf;
2293 user->u_plop.len = l;
2294 #ifdef ENCODINGS
2295 user->u_plop.enc = enc;
2296 #endif
2297 }
2298 else
2299 {
2300 struct plop *pp = plop_tab + (int)(unsigned char)dch;
2301 if (pp->buf)
2302 free(pp->buf);
2303 pp->buf = dbuf;
2304 pp->len = l;
2305 #ifdef ENCODINGS
2306 pp->enc = enc;
2307 #endif
2308 }
2309 }
2310 break;
2311 }
2312 case RC_WRITEBUF:
2313 if (!user->u_plop.buf)
2314 {
2315 Msg(0, "empty buffer");
2316 break;
2317 }
2318 #ifdef ENCODINGS
2319 {
2320 struct plop oldplop;
2321
2322 oldplop = user->u_plop;
2323 if (args[0] && args[1] && !strcmp(args[0], "-e"))
2324 {
2325 int enc, l;
2326 char *newbuf;
2327
2328 enc = FindEncoding(args[1]);
2329 if (enc == -1)
2330 {
2331 Msg(0, "%s: writebuf: unknown encoding", rc_name);
2332 break;
2333 }
2334 if (enc != oldplop.enc)
2335 {
2336 l = RecodeBuf((unsigned char *)oldplop.buf, oldplop.len, oldplop.enc, enc, (unsigned char *)0);
2337 newbuf = malloc(l + 1);
2338 if (!newbuf)
2339 {
2340 Msg(0, strnomem);
2341 break;
2342 }
2343 user->u_plop.len = RecodeBuf((unsigned char *)oldplop.buf, oldplop.len, oldplop.enc, enc, (unsigned char *)newbuf);
2344 user->u_plop.buf = newbuf;
2345 user->u_plop.enc = enc;
2346 }
2347 args += 2;
2348 }
2349 #endif
2350 if (args[0] && args[1])
2351 Msg(0, "%s: writebuf: too many arguments", rc_name);
2352 else
2353 WriteFile(user, args[0], DUMP_EXCHANGE);
2354 #ifdef ENCODINGS
2355 if (user->u_plop.buf != oldplop.buf)
2356 free(user->u_plop.buf);
2357 user->u_plop = oldplop;
2358 }
2359 #endif
2360 break;
2361 case RC_READBUF:
2362 #ifdef ENCODINGS
2363 i = fore ? fore->w_encoding : display ? display->d_encoding : 0;
2364 if (args[0] && args[1] && !strcmp(args[0], "-e"))
2365 {
2366 i = FindEncoding(args[1]);
2367 if (i == -1)
2368 {
2369 Msg(0, "%s: readbuf: unknown encoding", rc_name);
2370 break;
2371 }
2372 args += 2;
2373 }
2374 #endif
2375 if (args[0] && args[1])
2376 {
2377 Msg(0, "%s: readbuf: too many arguments", rc_name);
2378 break;
2379 }
2380 if ((s = ReadFile(args[0] ? args[0] : BufferFile, &n)))
2381 {
2382 if (user->u_plop.buf)
2383 UserFreeCopyBuffer(user);
2384 user->u_plop.len = n;
2385 user->u_plop.buf = s;
2386 #ifdef ENCODINGS
2387 user->u_plop.enc = i;
2388 #endif
2389 }
2390 break;
2391 case RC_REMOVEBUF:
2392 KillBuffers();
2393 break;
2394 case RC_IGNORECASE:
2395 (void)ParseSwitch(act, &search_ic);
2396 if (msgok)
2397 Msg(0, "Will %signore case in searches", search_ic ? "" : "not ");
2398 break;
2399 #endif /* COPY_PASTE */
2400 case RC_ESCAPE:
2401 if (*argl == 0)
2402 SetEscape(user, -1, -1);
2403 else if (*argl == 2)
2404 SetEscape(user, (int)(unsigned char)args[0][0], (int)(unsigned char)args[0][1]);
2405 else
2406 {
2407 Msg(0, "%s: two characters required after escape.", rc_name);
2408 break;
2409 }
2410 /* Change defescape if master user. This is because we only
2411 * have one ktab.
2412 */
2413 if (display && user != users)
2414 break;
2415 /* FALLTHROUGH */
2416 case RC_DEFESCAPE:
2417 if (*argl == 0)
2418 SetEscape(NULL, -1, -1);
2419 else if (*argl == 2)
2420 SetEscape(NULL, (int)(unsigned char)args[0][0], (int)(unsigned char)args[0][1]);
2421 else
2422 {
2423 Msg(0, "%s: two characters required after defescape.", rc_name);
2424 break;
2425 }
2426 #ifdef MAPKEYS
2427 CheckEscape();
2428 #endif
2429 break;
2430 case RC_CHDIR:
2431 s = *args ? *args : home;
2432 if (chdir(s) == -1)
2433 Msg(errno, "%s", s);
2434 break;
2435 case RC_SHELL:
2436 case RC_DEFSHELL:
2437 if (ParseSaveStr(act, &ShellProg) == 0)
2438 ShellArgs[0] = ShellProg;
2439 break;
2440 case RC_HARDCOPYDIR:
2441 if (*args)
2442 (void)ParseSaveStr(act, &hardcopydir);
2443 if (msgok)
2444 Msg(0, "hardcopydir is %s\n", hardcopydir && *hardcopydir ? hardcopydir : "<cwd>");
2445 break;
2446 case RC_LOGFILE:
2447 if (*args)
2448 {
2449 if (args[1] && !(strcmp(*args, "flush")))
2450 {
2451 log_flush = atoi(args[1]);
2452 if (msgok)
2453 Msg(0, "log flush timeout set to %ds\n", log_flush);
2454 break;
2455 }
2456 if (ParseSaveStr(act, &screenlogfile) || !msgok)
2457 break;
2458 }
2459 Msg(0, "logfile is '%s'", screenlogfile);
2460 break;
2461 case RC_LOGTSTAMP:
2462 if (!*args || !strcmp(*args, "on") || !strcmp(*args, "off"))
2463 {
2464 if (ParseSwitch(act, &logtstamp_on) == 0 && msgok)
2465 Msg(0, "timestamps turned %s", logtstamp_on ? "on" : "off");
2466 }
2467 else if (!strcmp(*args, "string"))
2468 {
2469 if (args[1])
2470 {
2471 if (logtstamp_string)
2472 free(logtstamp_string);
2473 logtstamp_string = SaveStr(args[1]);
2474 }
2475 if (msgok)
2476 Msg(0, "logfile timestamp is '%s'", logtstamp_string);
2477 }
2478 else if (!strcmp(*args, "after"))
2479 {
2480 if (args[1])
2481 {
2482 logtstamp_after = atoi(args[1]);
2483 if (!msgok)
2484 break;
2485 }
2486 Msg(0, "timestamp printed after %ds\n", logtstamp_after);
2487 }
2488 else
2489 Msg(0, "usage: logtstamp [after [n]|string [str]|on|off]");
2490 break;
2491 case RC_SHELLTITLE:
2492 (void)ParseSaveStr(act, &nwin_default.aka);
2493 break;
2494 case RC_TERMCAP:
2495 case RC_TERMCAPINFO:
2496 case RC_TERMINFO:
2497 if (!rc_name || !*rc_name)
2498 Msg(0, "Sorry, too late now. Place that in your .screenrc file.");
2499 break;
2500 case RC_SLEEP:
2501 break; /* Already handled */
2502 case RC_TERM:
2503 s = NULL;
2504 if (ParseSaveStr(act, &s))
2505 break;
2506 if (strlen(s) >= 20)
2507 {
2508 Msg(0, "%s: term: argument too long ( < 20)", rc_name);
2509 free(s);
2510 break;
2511 }
2512 strcpy(screenterm, s);
2513 free(s);
2514 debug1("screenterm set to %s\n", screenterm);
2515 MakeTermcap((display == 0));
2516 debug("new termcap made\n");
2517 break;
2518 case RC_ECHO:
2519 if (!msgok && (!rc_name || strcmp(rc_name, "-X")))
2520 break;
2521 /*
2522 * user typed ^A:echo... well, echo isn't FinishRc's job,
2523 * but as he wanted to test us, we show good will
2524 */
2525 if (argc > 1 && !strcmp(*args, "-n"))
2526 {
2527 args++;
2528 argc--;
2529 }
2530 s = *args;
2531 if (argc > 1 && !strcmp(*args, "-p"))
2532 {
2533 args++;
2534 argc--;
2535 s = *args;
2536 if (s)
2537 s = MakeWinMsg(s, fore, '%');
2538 }
2539 if (s)
2540 Msg(0, "%s", s);
2541 else
2542 Msg(0, "%s: 'echo [-n] [-p] \"string\"' expected.", rc_name);
2543 break;
2544 case RC_BELL:
2545 case RC_BELL_MSG:
2546 if (*args == 0)
2547 {
2548 char buf[256];
2549 AddXChars(buf, sizeof(buf), BellString);
2550 Msg(0, "bell_msg is '%s'", buf);
2551 break;
2552 }
2553 (void)ParseSaveStr(act, &BellString);
2554 break;
2555 #ifdef COPY_PASTE
2556 case RC_BUFFERFILE:
2557 if (*args == 0)
2558 BufferFile = SaveStr(DEFAULT_BUFFERFILE);
2559 else if (ParseSaveStr(act, &BufferFile))
2560 break;
2561 if (msgok)
2562 Msg(0, "Bufferfile is now '%s'", BufferFile);
2563 break;
2564 #endif
2565 case RC_ACTIVITY:
2566 (void)ParseSaveStr(act, &ActivityString);
2567 break;
2568 #if defined(DETACH) && defined(POW_DETACH)
2569 case RC_POW_DETACH_MSG:
2570 if (*args == 0)
2571 {
2572 char buf[256];
2573 AddXChars(buf, sizeof(buf), PowDetachString);
2574 Msg(0, "pow_detach_msg is '%s'", buf);
2575 break;
2576 }
2577 (void)ParseSaveStr(act, &PowDetachString);
2578 break;
2579 #endif
2580 #if defined(UTMPOK) && defined(LOGOUTOK)
2581 case RC_LOGIN:
2582 n = fore->w_slot != (slot_t)-1;
2583 if (*args && !strcmp(*args, "always"))
2584 {
2585 fore->w_lflag = 3;
2586 if (!displays && n)
2587 SlotToggle(n);
2588 break;
2589 }
2590 if (*args && !strcmp(*args, "attached"))
2591 {
2592 fore->w_lflag = 1;
2593 if (!displays && n)
2594 SlotToggle(0);
2595 break;
2596 }
2597 if (ParseSwitch(act, &n) == 0)
2598 SlotToggle(n);
2599 break;
2600 case RC_DEFLOGIN:
2601 if (!strcmp(*args, "always"))
2602 nwin_default.lflag |= 2;
2603 else if (!strcmp(*args, "attached"))
2604 nwin_default.lflag &= ~2;
2605 else
2606 (void)ParseOnOff(act, &nwin_default.lflag);
2607 break;
2608 #endif
2609 case RC_DEFFLOW:
2610 if (args[0] && args[1] && args[1][0] == 'i')
2611 {
2612 iflag = 1;
2613 for (display = displays; display; display = display->d_next)
2614 {
2615 if (!D_flow)
2616 continue;
2617 #if defined(TERMIO) || defined(POSIX)
2618 D_NewMode.tio.c_cc[VINTR] = D_OldMode.tio.c_cc[VINTR];
2619 D_NewMode.tio.c_lflag |= ISIG;
2620 #else /* TERMIO || POSIX */
2621 D_NewMode.m_tchars.t_intrc = D_OldMode.m_tchars.t_intrc;
2622 #endif /* TERMIO || POSIX */
2623 SetTTY(D_userfd, &D_NewMode);
2624 }
2625 }
2626 if (args[0] && args[0][0] == 'a')
2627 nwin_default.flowflag = FLOW_AUTOFLAG;
2628 else
2629 (void)ParseOnOff(act, &nwin_default.flowflag);
2630 break;
2631 case RC_DEFWRAP:
2632 (void)ParseOnOff(act, &nwin_default.wrap);
2633 break;
2634 case RC_DEFC1:
2635 (void)ParseOnOff(act, &nwin_default.c1);
2636 break;
2637 #ifdef COLOR
2638 case RC_DEFBCE:
2639 (void)ParseOnOff(act, &nwin_default.bce);
2640 break;
2641 #endif
2642 case RC_DEFGR:
2643 (void)ParseOnOff(act, &nwin_default.gr);
2644 break;
2645 case RC_DEFMONITOR:
2646 if (ParseOnOff(act, &n) == 0)
2647 nwin_default.monitor = (n == 0) ? MON_OFF : MON_ON;
2648 break;
2649 case RC_DEFSILENCE:
2650 if (ParseOnOff(act, &n) == 0)
2651 nwin_default.silence = (n == 0) ? SILENCE_OFF : SILENCE_ON;
2652 break;
2653 case RC_VERBOSE:
2654 if (!*args)
2655 Msg(0, "W%s echo command when creating windows.",
2656 VerboseCreate ? "ill" : "on't");
2657 else if (ParseOnOff(act, &n) == 0)
2658 VerboseCreate = n;
2659 break;
2660 case RC_HARDSTATUS:
2661 if (display)
2662 {
2663 Msg(0, "%s", ""); /* wait till mintime (keep gcc quiet) */
2664 RemoveStatus();
2665 }
2666 if (args[0] && strcmp(args[0], "on") && strcmp(args[0], "off"))
2667 {
2668 struct display *olddisplay = display;
2669 int old_use, new_use = -1;
2670
2671 s = args[0];
2672 if (!strncmp(s, "always", 6))
2673 s += 6;
2674 if (!strcmp(s, "lastline"))
2675 new_use = HSTATUS_LASTLINE;
2676 else if (!strcmp(s, "ignore"))
2677 new_use = HSTATUS_IGNORE;
2678 else if (!strcmp(s, "message"))
2679 new_use = HSTATUS_MESSAGE;
2680 else if (!strcmp(args[0], "string"))
2681 {
2682 if (!args[1])
2683 {
2684 char buf[256];
2685 AddXChars(buf, sizeof(buf), hstatusstring);
2686 Msg(0, "hardstatus string is '%s'", buf);
2687 break;
2688 }
2689 }
2690 else
2691 {
2692 Msg(0, "%s: usage: hardstatus [always]lastline|ignore|message|string [string]", rc_name);
2693 break;
2694 }
2695 if (new_use != -1)
2696 {
2697 hardstatusemu = new_use | (s == args[0] ? 0 : HSTATUS_ALWAYS);
2698 for (display = displays; display; display = display->d_next)
2699 {
2700 RemoveStatus();
2701 new_use = hardstatusemu & ~HSTATUS_ALWAYS;
2702 if (D_HS && s == args[0])
2703 new_use = HSTATUS_HS;
2704 ShowHStatus((char *)0);
2705 old_use = D_has_hstatus;
2706 D_has_hstatus = new_use;
2707 if ((new_use == HSTATUS_LASTLINE && old_use != HSTATUS_LASTLINE) || (new_use != HSTATUS_LASTLINE && old_use == HSTATUS_LASTLINE))
2708 ChangeScreenSize(D_width, D_height, 1);
2709 RefreshHStatus();
2710 }
2711 }
2712 if (args[1])
2713 {
2714 if (hstatusstring)
2715 free(hstatusstring);
2716 hstatusstring = SaveStr(args[1]);
2717 for (display = displays; display; display = display->d_next)
2718 RefreshHStatus();
2719 }
2720 display = olddisplay;
2721 break;
2722 }
2723 (void)ParseSwitch(act, &use_hardstatus);
2724 if (msgok)
2725 Msg(0, "messages displayed on %s", use_hardstatus ? "hardstatus line" : "window");
2726 break;
2727 case RC_CAPTION:
2728 if (strcmp(args[0], "always") == 0 || strcmp(args[0], "splitonly") == 0)
2729 {
2730 struct display *olddisplay = display;
2731
2732 captionalways = args[0][0] == 'a';
2733 for (display = displays; display; display = display->d_next)
2734 ChangeScreenSize(D_width, D_height, 1);
2735 display = olddisplay;
2736 }
2737 else if (strcmp(args[0], "string") == 0)
2738 {
2739 if (!args[1])
2740 {
2741 char buf[256];
2742 AddXChars(buf, sizeof(buf), captionstring);
2743 Msg(0, "caption string is '%s'", buf);
2744 break;
2745 }
2746 }
2747 else
2748 {
2749 Msg(0, "%s: usage: caption always|splitonly|string <string>", rc_name);
2750 break;
2751 }
2752 if (!args[1])
2753 break;
2754 if (captionstring)
2755 free(captionstring);
2756 captionstring = SaveStr(args[1]);
2757 RedisplayDisplays(0);
2758 break;
2759 case RC_CONSOLE:
2760 n = (console_window != 0);
2761 if (ParseSwitch(act, &n))
2762 break;
2763 if (TtyGrabConsole(fore->w_ptyfd, n, rc_name))
2764 break;
2765 if (n == 0)
2766 Msg(0, "%s: releasing console %s", rc_name, HostName);
2767 else if (console_window)
2768 Msg(0, "%s: stealing console %s from window %d (%s)", rc_name,
2769 HostName, console_window->w_number, console_window->w_title);
2770 else
2771 Msg(0, "%s: grabbing console %s", rc_name, HostName);
2772 console_window = n ? fore : 0;
2773 break;
2774 case RC_ALLPARTIAL:
2775 if (ParseOnOff(act, &all_norefresh))
2776 break;
2777 if (!all_norefresh && fore)
2778 Activate(-1);
2779 if (msgok)
2780 Msg(0, all_norefresh ? "No refresh on window change!\n" :
2781 "Window specific refresh\n");
2782 break;
2783 case RC_PARTIAL:
2784 (void)ParseSwitch(act, &n);
2785 fore->w_norefresh = n;
2786 break;
2787 case RC_VBELL:
2788 if (ParseSwitch(act, &visual_bell) || !msgok)
2789 break;
2790 if (visual_bell == 0)
2791 Msg(0, "switched to audible bell.");
2792 else
2793 Msg(0, "switched to visual bell.");
2794 break;
2795 case RC_VBELLWAIT:
2796 if (ParseNum1000(act, &VBellWait) == 0 && msgok)
2797 Msg(0, "vbellwait set to %.10g seconds", VBellWait/1000.);
2798 break;
2799 case RC_MSGWAIT:
2800 if (ParseNum1000(act, &MsgWait) == 0 && msgok)
2801 Msg(0, "msgwait set to %.10g seconds", MsgWait/1000.);
2802 break;
2803 case RC_MSGMINWAIT:
2804 if (ParseNum1000(act, &MsgMinWait) == 0 && msgok)
2805 Msg(0, "msgminwait set to %.10g seconds", MsgMinWait/1000.);
2806 break;
2807 case RC_SILENCEWAIT:
2808 if (ParseNum(act, &SilenceWait))
2809 break;
2810 if (SilenceWait < 1)
2811 SilenceWait = 1;
2812 for (p = windows; p; p = p->w_next)
2813 p->w_silencewait = SilenceWait;
2814 if (msgok)
2815 Msg(0, "silencewait set to %d seconds", SilenceWait);
2816 break;
2817 case RC_NUMBER:
2818 if (*args == 0)
2819 Msg(0, "This is window %d (%s).\n", fore->w_number, fore->w_title);
2820 else
2821 {
2822 int old = fore->w_number;
2823 int rel = 0, parse;
2824 if (args[0][0] == '+')
2825 rel = 1;
2826 else if (args[0][0] == '-')
2827 rel = -1;
2828 if (rel)
2829 ++act->args[0];
2830 parse = ParseNum(act, &n);
2831 if (rel)
2832 --act->args[0];
2833 if (parse)
2834 break;
2835 if (rel > 0)
2836 n += old;
2837 else if (rel < 0)
2838 n = old - n;
2839 if (n < 0 || n >= maxwin)
2840 {
2841 Msg(0, "Given window position is invalid.");
2842 return;
2843 }
2844 p = wtab[n];
2845 wtab[n] = fore;
2846 fore->w_number = n;
2847 wtab[old] = p;
2848 if (p)
2849 p->w_number = old;
2850 #ifdef MULTIUSER
2851 /* exchange the acls for these windows. */
2852 AclWinSwap(old, n);
2853 #endif
2854 #ifdef UTMPOK
2855 /* exchange the utmp-slots for these windows */
2856 if ((fore->w_slot != (slot_t) -1) && (fore->w_slot != (slot_t) 0))
2857 {
2858 RemoveUtmp(fore);
2859 SetUtmp(fore);
2860 }
2861 if (p && (p->w_slot != (slot_t) -1) && (p->w_slot != (slot_t) 0))
2862 {
2863 /* XXX: first display wins? */
2864 display = fore->w_layer.l_cvlist ? fore->w_layer.l_cvlist->c_display : 0;
2865 RemoveUtmp(p);
2866 SetUtmp(p);
2867 }
2868 #endif
2869
2870 WindowChanged(fore, 'n');
2871 WindowChanged((struct win *)0, 'w');
2872 WindowChanged((struct win *)0, 'W');
2873 WindowChanged((struct win *)0, 0);
2874 }
2875 break;
2876 case RC_SILENCE:
2877 n = fore->w_silence != 0;
2878 i = fore->w_silencewait;
2879 if (args[0] && (args[0][0] == '-' || (args[0][0] >= '0' && args[0][0] <= '9')))
2880 {
2881 if (ParseNum(act, &i))
2882 break;
2883 n = i > 0;
2884 }
2885 else if (ParseSwitch(act, &n))
2886 break;
2887 if (n)
2888 {
2889 #ifdef MULTIUSER
2890 if (display) /* we tell only this user */
2891 ACLBYTE(fore->w_lio_notify, D_user->u_id) |= ACLBIT(D_user->u_id);
2892 else
2893 for (n = 0; n < maxusercount; n++)
2894 ACLBYTE(fore->w_lio_notify, n) |= ACLBIT(n);
2895 #endif
2896 fore->w_silencewait = i;
2897 fore->w_silence = SILENCE_ON;
2898 SetTimeout(&fore->w_silenceev, fore->w_silencewait * 1000);
2899 evenq(&fore->w_silenceev);
2900
2901 if (!msgok)
2902 break;
2903 Msg(0, "The window is now being monitored for %d sec. silence.", fore->w_silencewait);
2904 }
2905 else
2906 {
2907 #ifdef MULTIUSER
2908 if (display) /* we remove only this user */
2909 ACLBYTE(fore->w_lio_notify, D_user->u_id)
2910 &= ~ACLBIT(D_user->u_id);
2911 else
2912 for (n = 0; n < maxusercount; n++)
2913 ACLBYTE(fore->w_lio_notify, n) &= ~ACLBIT(n);
2914 for (i = maxusercount - 1; i >= 0; i--)
2915 if (ACLBYTE(fore->w_lio_notify, i))
2916 break;
2917 if (i < 0)
2918 #endif
2919 {
2920 fore->w_silence = SILENCE_OFF;
2921 evdeq(&fore->w_silenceev);
2922 }
2923 if (!msgok)
2924 break;
2925 Msg(0, "The window is no longer being monitored for silence.");
2926 }
2927 break;
2928 #ifdef COPY_PASTE
2929 case RC_DEFSCROLLBACK:
2930 (void)ParseNum(act, &nwin_default.histheight);
2931 break;
2932 case RC_SCROLLBACK:
2933 if (flayer->l_layfn == &MarkLf)
2934 {
2935 Msg(0, "Cannot resize scrollback buffer in copy/scrollback mode.");
2936 break;
2937 }
2938 (void)ParseNum(act, &n);
2939 ChangeWindowSize(fore, fore->w_width, fore->w_height, n);
2940 if (msgok)
2941 Msg(0, "scrollback set to %d", fore->w_histheight);
2942 break;
2943 #endif
2944 case RC_SESSIONNAME:
2945 if (*args == 0)
2946 Msg(0, "This session is named '%s'\n", SockName);
2947 else
2948 {
2949 char buf[MAXPATHLEN];
2950
2951 s = 0;
2952 if (ParseSaveStr(act, &s))
2953 break;
2954 if (!*s || strlen(s) + (SockName - SockPath) > MAXPATHLEN - 13 || index(s, '/'))
2955 {
2956 Msg(0, "%s: bad session name '%s'\n", rc_name, s);
2957 free(s);
2958 break;
2959 }
2960 strncpy(buf, SockPath, SockName - SockPath);
2961 sprintf(buf + (SockName - SockPath), "%d.%s", (int)getpid(), s);
2962 free(s);
2963 if ((access(buf, F_OK) == 0) || (errno != ENOENT))
2964 {
2965 Msg(0, "%s: inappropriate path: '%s'.", rc_name, buf);
2966 break;
2967 }
2968 if (rename(SockPath, buf))
2969 {
2970 Msg(errno, "%s: failed to rename(%s, %s)", rc_name, SockPath, buf);
2971 break;
2972 }
2973 debug2("rename(%s, %s) done\n", SockPath, buf);
2974 strcpy(SockPath, buf);
2975 MakeNewEnv();
2976 }
2977 break;
2978 case RC_SETENV:
2979 if (!args[0] || !args[1])
2980 {
2981 debug1("RC_SETENV arguments missing: %s\n", args[0] ? args[0] : "");
2982 InputSetenv(args[0]);
2983 }
2984 else
2985 {
2986 xsetenv(args[0], args[1]);
2987 MakeNewEnv();
2988 }
2989 break;
2990 case RC_UNSETENV:
2991 unsetenv(*args);
2992 MakeNewEnv();
2993 break;
2994 #ifdef COPY_PASTE
2995 case RC_DEFSLOWPASTE:
2996 (void)ParseNum(act, &nwin_default.slow);
2997 break;
2998 case RC_SLOWPASTE:
2999 if (*args == 0)
3000 Msg(0, fore->w_slowpaste ?
3001 "Slowpaste in window %d is %d milliseconds." :
3002 "Slowpaste in window %d is unset.",
3003 fore->w_number, fore->w_slowpaste);
3004 else if (ParseNum(act, &fore->w_slowpaste) == 0 && msgok)
3005 Msg(0, fore->w_slowpaste ?
3006 "Slowpaste in window %d set to %d milliseconds." :
3007 "Slowpaste in window %d now unset.",
3008 fore->w_number, fore->w_slowpaste);
3009 break;
3010 case RC_MARKKEYS:
3011 if (CompileKeys(*args, *argl, mark_key_tab))
3012 {
3013 Msg(0, "%s: markkeys: syntax error.", rc_name);
3014 break;
3015 }
3016 debug1("markkeys %s\n", *args);
3017 break;
3018 # ifdef FONT
3019 case RC_PASTEFONT:
3020 if (ParseSwitch(act, &pastefont) == 0 && msgok)
3021 Msg(0, "Will %spaste font settings", pastefont ? "" : "not ");
3022 break;
3023 # endif
3024 case RC_CRLF:
3025 (void)ParseSwitch(act, &join_with_cr);
3026 break;
3027 case RC_COMPACTHIST:
3028 if (ParseSwitch(act, &compacthist) == 0 && msgok)
3029 Msg(0, "%scompacting history lines", compacthist ? "" : "not ");
3030 break;
3031 #endif
3032 #ifdef NETHACK
3033 case RC_NETHACK:
3034 (void)ParseOnOff(act, &nethackflag);
3035 break;
3036 #endif
3037 case RC_HARDCOPY_APPEND:
3038 (void)ParseOnOff(act, &hardcopy_append);
3039 break;
3040 case RC_VBELL_MSG:
3041 if (*args == 0)
3042 {
3043 char buf[256];
3044 AddXChars(buf, sizeof(buf), VisualBellString);
3045 Msg(0, "vbell_msg is '%s'", buf);
3046 break;
3047 }
3048 (void)ParseSaveStr(act, &VisualBellString);
3049 debug1(" new vbellstr '%s'\n", VisualBellString);
3050 break;
3051 case RC_DEFMODE:
3052 if (ParseBase(act, *args, &n, 8, "octal"))
3053 break;
3054 if (n < 0 || n > 0777)
3055 {
3056 Msg(0, "%s: mode: Invalid tty mode %o", rc_name, n);
3057 break;
3058 }
3059 TtyMode = n;
3060 if (msgok)
3061 Msg(0, "Ttymode set to %03o", TtyMode);
3062 break;
3063 case RC_AUTODETACH:
3064 (void)ParseOnOff(act, &auto_detach);
3065 break;
3066 case RC_STARTUP_MESSAGE:
3067 (void)ParseOnOff(act, &default_startup);
3068 break;
3069 #ifdef PASSWORD
3070 case RC_PASSWORD:
3071 if (*args)
3072 {
3073 n = (*user->u_password) ? 1 : 0;
3074 if (user->u_password != NullStr) free((char *)user->u_password);
3075 user->u_password = SaveStr(*args);
3076 if (!strcmp(user->u_password, "none"))
3077 {
3078 if (n)
3079 Msg(0, "Password checking disabled");
3080 free(user->u_password);
3081 user->u_password = NullStr;
3082 }
3083 }
3084 else
3085 {
3086 if (!fore)
3087 {
3088 Msg(0, "%s: password: window required", rc_name);
3089 break;
3090 }
3091 Input("New screen password:", 100, INP_NOECHO, pass1, display ? (char *)D_user : (char *)users, 0);
3092 }
3093 break;
3094 #endif /* PASSWORD */
3095 case RC_BIND:
3096 {
3097 struct action *ktabp = ktab;
3098 int kflag = 0;
3099
3100 for (;;)
3101 {
3102 if (argc > 2 && !strcmp(*args, "-c"))
3103 {
3104 ktabp = FindKtab(args[1], 1);
3105 if (ktabp == 0)
3106 break;
3107 args += 2;
3108 argl += 2;
3109 argc -= 2;
3110 }
3111 else if (argc > 1 && !strcmp(*args, "-k"))
3112 {
3113 kflag = 1;
3114 args++;
3115 argl++;
3116 argc--;
3117 }
3118 else
3119 break;
3120 }
3121 #ifdef MAPKEYS
3122 if (kflag)
3123 {
3124 for (n = 0; n < KMAP_KEYS; n++)
3125 if (strcmp(term[n + T_CAPS].tcname, *args) == 0)
3126 break;
3127 if (n == KMAP_KEYS)
3128 {
3129 Msg(0, "%s: bind: unknown key '%s'", rc_name, *args);
3130 break;
3131 }
3132 n += 256;
3133 }
3134 else
3135 #endif
3136 if (*argl != 1)
3137 {
3138 Msg(0, "%s: bind: character, ^x, or (octal) \\032 expected.", rc_name);
3139 break;
3140 }
3141 else
3142 n = (unsigned char)args[0][0];
3143
3144 if (args[1])
3145 {
3146 if ((i = FindCommnr(args[1])) == RC_ILLEGAL)
3147 {
3148 Msg(0, "%s: bind: unknown command '%s'", rc_name, args[1]);
3149 break;
3150 }
3151 if (CheckArgNum(i, args + 2) < 0)
3152 break;
3153 ClearAction(&ktabp[n]);
3154 SaveAction(ktabp + n, i, args + 2, argl + 2);
3155 }
3156 else
3157 ClearAction(&ktabp[n]);
3158 }
3159 break;
3160 #ifdef MAPKEYS
3161 case RC_BINDKEY:
3162 {
3163 struct action *newact;
3164 int newnr, fl = 0, kf = 0, af = 0, df = 0, mf = 0;
3165 struct display *odisp = display;
3166 int used = 0;
3167 struct kmap_ext *kme;
3168
3169 for (; *args && **args == '-'; args++, argl++)
3170 {
3171 if (strcmp(*args, "-t") == 0)
3172 fl = KMAP_NOTIMEOUT;
3173 else if (strcmp(*args, "-k") == 0)
3174 kf = 1;
3175 else if (strcmp(*args, "-a") == 0)
3176 af = 1;
3177 else if (strcmp(*args, "-d") == 0)
3178 df = 1;
3179 else if (strcmp(*args, "-m") == 0)
3180 mf = 1;
3181 else if (strcmp(*args, "--") == 0)
3182 {
3183 args++;
3184 argl++;
3185 break;
3186 }
3187 else
3188 {
3189 Msg(0, "%s: bindkey: invalid option %s", rc_name, *args);
3190 return;
3191 }
3192 }
3193 if (df && mf)
3194 {
3195 Msg(0, "%s: bindkey: -d does not work with -m", rc_name);
3196 break;
3197 }
3198 if (*args == 0)
3199 {
3200 if (mf)
3201 display_bindkey("Edit mode", mmtab);
3202 else if (df)
3203 display_bindkey("Default", dmtab);
3204 else
3205 display_bindkey("User", umtab);
3206 break;
3207 }
3208 if (kf == 0)
3209 {
3210 if (af)
3211 {
3212 Msg(0, "%s: bindkey: -a only works with -k", rc_name);
3213 break;
3214 }
3215 if (*argl == 0)
3216 {
3217 Msg(0, "%s: bindkey: empty string makes no sense", rc_name);
3218 break;
3219 }
3220 for (i = 0, kme = kmap_exts; i < kmap_extn; i++, kme++)
3221 if (kme->str == 0)
3222 {
3223 if (args[1])
3224 break;
3225 }
3226 else
3227 if (*argl == (kme->fl & ~KMAP_NOTIMEOUT) && bcmp(kme->str, *args, *argl) == 0)
3228 break;
3229 if (i == kmap_extn)
3230 {
3231 if (!args[1])
3232 {
3233 Msg(0, "%s: bindkey: keybinding not found", rc_name);
3234 break;
3235 }
3236 kmap_extn += 8;
3237 kmap_exts = (struct kmap_ext *)xrealloc((char *)kmap_exts, kmap_extn * sizeof(*kmap_exts));
3238 kme = kmap_exts + i;
3239 bzero((char *)kme, 8 * sizeof(*kmap_exts));
3240 for (; i < kmap_extn; i++, kme++)
3241 {
3242 kme->str = 0;
3243 kme->dm.nr = kme->mm.nr = kme->um.nr = RC_ILLEGAL;
3244 kme->dm.args = kme->mm.args = kme->um.args = noargs;
3245 }
3246 i -= 8;
3247 kme -= 8;
3248 }
3249 if (df == 0 && kme->dm.nr != RC_ILLEGAL)
3250 used = 1;
3251 if (mf == 0 && kme->mm.nr != RC_ILLEGAL)
3252 used = 1;
3253 if ((df || mf) && kme->um.nr != RC_ILLEGAL)
3254 used = 1;
3255 i += KMAP_KEYS + KMAP_AKEYS;
3256 newact = df ? &kme->dm : mf ? &kme->mm : &kme->um;
3257 }
3258 else
3259 {
3260 for (i = T_CAPS; i < T_OCAPS; i++)
3261 if (strcmp(term[i].tcname, *args) == 0)
3262 break;
3263 if (i == T_OCAPS)
3264 {
3265 Msg(0, "%s: bindkey: unknown key '%s'", rc_name, *args);
3266 break;
3267 }
3268 if (af && i >= T_CURSOR && i < T_OCAPS)
3269 i -= T_CURSOR - KMAP_KEYS;
3270 else
3271 i -= T_CAPS;
3272 newact = df ? &dmtab[i] : mf ? &mmtab[i] : &umtab[i];
3273 }
3274 if (args[1])
3275 {
3276 if ((newnr = FindCommnr(args[1])) == RC_ILLEGAL)
3277 {
3278 Msg(0, "%s: bindkey: unknown command '%s'", rc_name, args[1]);
3279 break;
3280 }
3281 if (CheckArgNum(newnr, args + 2) < 0)
3282 break;
3283 ClearAction(newact);
3284 SaveAction(newact, newnr, args + 2, argl + 2);
3285 if (kf == 0 && args[1])
3286 {
3287 if (kme->str)
3288 free(kme->str);
3289 kme->str = SaveStrn(*args, *argl);
3290 kme->fl = fl | *argl;
3291 }
3292 }
3293 else
3294 ClearAction(newact);
3295 for (display = displays; display; display = display->d_next)
3296 remap(i, args[1] ? 1 : 0);
3297 if (kf == 0 && !args[1])
3298 {
3299 if (!used && kme->str)
3300 {
3301 free(kme->str);
3302 kme->str = 0;
3303 kme->fl = 0;
3304 }
3305 }
3306 display = odisp;
3307 }
3308 break;
3309 case RC_MAPTIMEOUT:
3310 if (*args)
3311 {
3312 if (ParseNum(act, &n))
3313 break;
3314 if (n < 0)
3315 {
3316 Msg(0, "%s: maptimeout: illegal time %d", rc_name, n);
3317 break;
3318 }
3319 maptimeout = n;
3320 }
3321 if (*args == 0 || msgok)
3322 Msg(0, "maptimeout is %dms", maptimeout);
3323 break;
3324 case RC_MAPNOTNEXT:
3325 D_dontmap = 1;
3326 break;
3327 case RC_MAPDEFAULT:
3328 D_mapdefault = 1;
3329 break;
3330 #endif
3331 #ifdef MULTIUSER
3332 case RC_ACLCHG:
3333 case RC_ACLADD:
3334 case RC_ADDACL:
3335 case RC_CHACL:
3336 UsersAcl(NULL, argc, args);
3337 break;
3338 case RC_ACLDEL:
3339 if (UserDel(args[0], NULL))
3340 break;
3341 if (msgok)
3342 Msg(0, "%s removed from acl database", args[0]);
3343 break;
3344 case RC_ACLGRP:
3345 /*
3346 * modify a user to gain or lose rights granted to a group.
3347 * This group is actually a normal user whose rights were defined
3348 * with chacl in the usual way.
3349 */
3350 if (args[1])
3351 {
3352 if (strcmp(args[1], "none")) /* link a user to another user */
3353 {
3354 if (AclLinkUser(args[0], args[1]))
3355 break;
3356 if (msgok)
3357 Msg(0, "User %s joined acl-group %s", args[0], args[1]);
3358 }
3359 else /* remove all groups from user */
3360 {
3361 struct acluser *u;
3362 struct aclusergroup *g;
3363
3364 if (!(u = *FindUserPtr(args[0])))
3365 break;
3366 while ((g = u->u_group))
3367 {
3368 u->u_group = g->next;
3369 free((char *)g);
3370 }
3371 }
3372 }
3373 else /* show all groups of user */
3374 {
3375 char buf[256], *p = buf;
3376 int ngroups = 0;
3377 struct acluser *u;
3378 struct aclusergroup *g;
3379
3380 if (!(u = *FindUserPtr(args[0])))
3381 {
3382 if (msgok)
3383 Msg(0, "User %s does not exist.", args[0]);
3384 break;
3385 }
3386 g = u->u_group;
3387 while (g)
3388 {
3389 ngroups++;
3390 sprintf(p, "%s ", g->u->u_name);
3391 p += strlen(p);
3392 if (p > buf+200)
3393 break;
3394 g = g->next;
3395 }
3396 if (ngroups)
3397 *(--p) = '\0';
3398 Msg(0, "%s's group%s: %s.", args[0], (ngroups == 1) ? "" : "s",
3399 (ngroups == 0) ? "none" : buf);
3400 }
3401 break;
3402 case RC_ACLUMASK:
3403 case RC_UMASK:
3404 while ((s = *args++))
3405 {
3406 char *err = 0;
3407
3408 if (AclUmask(display ? D_user : users, s, &err))
3409 Msg(0, "umask: %s\n", err);
3410 }
3411 break;
3412 case RC_MULTIUSER:
3413 if (ParseOnOff(act, &n))
3414 break;
3415 multi = n ? "" : 0;
3416 chsock();
3417 if (msgok)
3418 Msg(0, "Multiuser mode %s", multi ? "enabled" : "disabled");
3419 break;
3420 #endif /* MULTIUSER */
3421 #ifdef PSEUDOS
3422 case RC_EXEC:
3423 winexec(args);
3424 break;
3425 #endif
3426 #ifdef MULTI
3427 case RC_NONBLOCK:
3428 i = D_nonblock >= 0;
3429 if (*args && ((args[0][0] >= '0' && args[0][0] <= '9') || args[0][0] == '.'))
3430 {
3431 if (ParseNum1000(act, &i))
3432 break;
3433 }
3434 else if (!ParseSwitch(act, &i))
3435 i = i == 0 ? -1 : 1000;
3436 else
3437 break;
3438 if (msgok && i == -1)
3439 Msg(0, "display set to blocking mode");
3440 else if (msgok && i == 0)
3441 Msg(0, "display set to nonblocking mode, no timeout");
3442 else if (msgok)
3443 Msg(0, "display set to nonblocking mode, %.10gs timeout", i/1000.);
3444 D_nonblock = i;
3445 if (D_nonblock <= 0)
3446 evdeq(&D_blockedev);
3447 break;
3448 case RC_DEFNONBLOCK:
3449 if (*args && ((args[0][0] >= '0' && args[0][0] <= '9') || args[0][0] == '.'))
3450 {
3451 if (ParseNum1000(act, &defnonblock))
3452 break;
3453 }
3454 else if (!ParseOnOff(act, &defnonblock))
3455 defnonblock = defnonblock == 0 ? -1 : 1000;
3456 else
3457 break;
3458 if (display && *rc_name)
3459 {
3460 D_nonblock = defnonblock;
3461 if (D_nonblock <= 0)
3462 evdeq(&D_blockedev);
3463 }
3464 break;
3465 #endif
3466 case RC_GR:
3467 #ifdef ENCODINGS
3468 if (fore->w_gr == 2)
3469 fore->w_gr = 0;
3470 #endif
3471 if (ParseSwitch(act, &fore->w_gr) == 0 && msgok)
3472 Msg(0, "Will %suse GR", fore->w_gr ? "" : "not ");
3473 #ifdef ENCODINGS
3474 if (fore->w_gr == 0 && fore->w_FontE)
3475 fore->w_gr = 2;
3476 #endif
3477 break;
3478 case RC_C1:
3479 if (ParseSwitch(act, &fore->w_c1) == 0 && msgok)
3480 Msg(0, "Will %suse C1", fore->w_c1 ? "" : "not ");
3481 break;
3482 #ifdef COLOR
3483 case RC_BCE:
3484 if (ParseSwitch(act, &fore->w_bce) == 0 && msgok)
3485 Msg(0, "Will %serase with background color", fore->w_bce ? "" : "not ");
3486 break;
3487 #endif
3488 #ifdef ENCODINGS
3489 case RC_KANJI:
3490 case RC_ENCODING:
3491 #ifdef UTF8
3492 if (*args && !strcmp(args[0], "-d"))
3493 {
3494 if (!args[1])
3495 Msg(0, "encodings directory is %s", screenencodings ? screenencodings : "<unset>");
3496 else
3497 {
3498 free(screenencodings);
3499 screenencodings = SaveStr(args[1]);
3500 }
3501 break;
3502 }
3503 if (*args && !strcmp(args[0], "-l"))
3504 {
3505 if (!args[1])
3506 Msg(0, "encoding: -l: argument required");
3507 else if (LoadFontTranslation(-1, args[1]))
3508 Msg(0, "encoding: could not load utf8 encoding file");
3509 else if (msgok)
3510 Msg(0, "encoding: utf8 encoding file loaded");
3511 break;
3512 }
3513 #else
3514 if (*args && (!strcmp(args[0], "-l") || !strcmp(args[0], "-d")))
3515 {
3516 if (msgok)
3517 Msg(0, "encoding: screen is not compiled for UTF-8.");
3518 break;
3519 }
3520 #endif
3521 for (i = 0; i < 2; i++)
3522 {
3523 if (args[i] == 0)
3524 break;
3525 if (!strcmp(args[i], "."))
3526 continue;
3527 n = FindEncoding(args[i]);
3528 if (n == -1)
3529 {
3530 Msg(0, "encoding: unknown encoding '%s'", args[i]);
3531 break;
3532 }
3533 if (i == 0 && fore)
3534 {
3535 WinSwitchEncoding(fore, n);
3536 ResetCharsets(fore);
3537 }
3538 else if (i && display)
3539 D_encoding = n;
3540 }
3541 break;
3542 case RC_DEFKANJI:
3543 case RC_DEFENCODING:
3544 n = FindEncoding(*args);
3545 if (n == -1)
3546 {
3547 Msg(0, "defencoding: unknown encoding '%s'", *args);
3548 break;
3549 }
3550 nwin_default.encoding = n;
3551 break;
3552 #endif
3553
3554 #ifdef UTF8
3555 case RC_DEFUTF8:
3556 n = nwin_default.encoding == UTF8;
3557 if (ParseSwitch(act, &n) == 0)
3558 {
3559 nwin_default.encoding = n ? UTF8 : 0;
3560 if (msgok)
3561 Msg(0, "Will %suse UTF-8 encoding for new windows", n ? "" : "not ");
3562 }
3563 break;
3564 case RC_UTF8:
3565 for (i = 0; i < 2; i++)
3566 {
3567 if (i && args[i] == 0)
3568 break;
3569 if (args[i] == 0)
3570 n = fore->w_encoding != UTF8;
3571 else if (strcmp(args[i], "off") == 0)
3572 n = 0;
3573 else if (strcmp(args[i], "on") == 0)
3574 n = 1;
3575 else
3576 {
3577 Msg(0, "utf8: illegal argument (%s)", args[i]);
3578 break;
3579 }
3580 if (i == 0)
3581 {
3582 WinSwitchEncoding(fore, n ? UTF8 : 0);
3583 if (msgok)
3584 Msg(0, "Will %suse UTF-8 encoding", n ? "" : "not ");
3585 }
3586 else if (display)
3587 D_encoding = n ? UTF8 : 0;
3588 if (args[i] == 0)
3589 break;
3590 }
3591 break;
3592 #endif
3593
3594 case RC_PRINTCMD:
3595 if (*args)
3596 {
3597 if (printcmd)
3598 free(printcmd);
3599 printcmd = 0;
3600 if (**args)
3601 printcmd = SaveStr(*args);
3602 }
3603 if (*args == 0 || msgok)
3604 {
3605 if (printcmd)
3606 Msg(0, "using '%s' as print command", printcmd);
3607 else
3608 Msg(0, "using termcap entries for printing");
3609 break;
3610 }
3611 break;
3612
3613 case RC_DIGRAPH:
3614 Input("Enter digraph: ", 10, INP_EVERY, digraph_fn, NULL, 0);
3615 if (*args && **args)
3616 {
3617 s = *args;
3618 n = strlen(s);
3619 LayProcess(&s, &n);
3620 }
3621 break;
3622
3623 case RC_DEFHSTATUS:
3624 if (*args == 0)
3625 {
3626 char buf[256];
3627 *buf = 0;
3628 if (nwin_default.hstatus)
3629 AddXChars(buf, sizeof(buf), nwin_default.hstatus);
3630 Msg(0, "default hstatus is '%s'", buf);
3631 break;
3632 }
3633 (void)ParseSaveStr(act, &nwin_default.hstatus);
3634 if (*nwin_default.hstatus == 0)
3635 {
3636 free(nwin_default.hstatus);
3637 nwin_default.hstatus = 0;
3638 }
3639 break;
3640 case RC_HSTATUS:
3641 (void)ParseSaveStr(act, &fore->w_hstatus);
3642 if (*fore->w_hstatus == 0)
3643 {
3644 free(fore->w_hstatus);
3645 fore->w_hstatus = 0;
3646 }
3647 WindowChanged(fore, 'h');
3648 break;
3649
3650 #ifdef FONT
3651 case RC_DEFCHARSET:
3652 case RC_CHARSET:
3653 if (*args == 0)
3654 {
3655 char buf[256];
3656 *buf = 0;
3657 if (nwin_default.charset)
3658 AddXChars(buf, sizeof(buf), nwin_default.charset);
3659 Msg(0, "default charset is '%s'", buf);
3660 break;
3661 }
3662 n = strlen(*args);
3663 if (n == 0 || n > 6)
3664 {
3665 Msg(0, "%s: %s: string has illegal size.", rc_name, comms[nr].name);
3666 break;
3667 }
3668 if (n > 4 && (
3669 ((args[0][4] < '0' || args[0][4] > '3') && args[0][4] != '.') ||
3670 ((args[0][5] < '0' || args[0][5] > '3') && args[0][5] && args[0][5] != '.')))
3671 {
3672 Msg(0, "%s: %s: illegal mapping number.", rc_name, comms[nr].name);
3673 break;
3674 }
3675 if (nr == RC_CHARSET)
3676 {
3677 SetCharsets(fore, *args);
3678 break;
3679 }
3680 if (nwin_default.charset)
3681 free(nwin_default.charset);
3682 nwin_default.charset = SaveStr(*args);
3683 break;
3684 #endif
3685 #ifdef COLOR
3686 case RC_ATTRCOLOR:
3687 s = args[0];
3688 if (*s >= '0' && *s <= '9')
3689 i = *s - '0';
3690 else
3691 for (i = 0; i < 8; i++)
3692 if (*s == "dubrsBiI"[i])
3693 break;
3694 s++;
3695 nr = 0;
3696 if (*s && s[1] && !s[2])
3697 {
3698 if (*s == 'd' && s[1] == 'd')
3699 nr = 3;
3700 else if (*s == '.' && s[1] == 'd')
3701 nr = 2;
3702 else if (*s == 'd' && s[1] == '.')
3703 nr = 1;
3704 else if (*s != '.' || s[1] != '.')
3705 s--;
3706 s += 2;
3707 }
3708 if (*s || i < 0 || i >= 8)
3709 {
3710 Msg(0, "%s: attrcolor: unknown attribute '%s'.", rc_name, args[0]);
3711 break;
3712 }
3713 n = 0;
3714 if (args[1])
3715 n = ParseAttrColor(args[1], args[2], 1);
3716 if (n == -1)
3717 break;
3718 attr2color[i][nr] = n;
3719 n = 0;
3720 for (i = 0; i < 8; i++)
3721 if (attr2color[i][0] || attr2color[i][1] || attr2color[i][2] || attr2color[i][3])
3722 n |= 1 << i;
3723 nattr2color = n;
3724 break;
3725 #endif
3726 case RC_SORENDITION:
3727 i = 0;
3728 if (*args)
3729 {
3730 i = ParseAttrColor(*args, args[1], 1);
3731 if (i == -1)
3732 break;
3733 ApplyAttrColor(i, &mchar_so);
3734 debug2("--> %x %x\n", mchar_so.attr, mchar_so.color);
3735 }
3736 if (msgok)
3737 #ifdef COLOR
3738 Msg(0, "Standout attributes 0x%02x color 0x%02x", (unsigned char)mchar_so.attr, 0x99 ^ (unsigned char)mchar_so.color);
3739 #else
3740 Msg(0, "Standout attributes 0x%02x ", (unsigned char)mchar_so.attr);
3741 #endif
3742 break;
3743
3744 case RC_SOURCE:
3745 do_source(*args);
3746 break;
3747
3748 #ifdef MULTIUSER
3749 case RC_SU:
3750 s = NULL;
3751 if (!*args)
3752 {
3753 Msg(0, "%s:%s screen login", HostName, SockPath);
3754 InputSu(D_fore, &D_user, NULL);
3755 }
3756 else if (!args[1])
3757 InputSu(D_fore, &D_user, args[0]);
3758 else if (!args[2])
3759 s = DoSu(&D_user, args[0], args[1], "\377");
3760 else
3761 s = DoSu(&D_user, args[0], args[1], args[2]);
3762 if (s)
3763 Msg(0, "%s", s);
3764 break;
3765 #endif /* MULTIUSER */
3766 case RC_SPLIT:
3767 s = args[0];
3768 if (s && !strcmp(s, "-v"))
3769 AddCanvas(SLICE_HORI);
3770 else
3771 AddCanvas(SLICE_VERT);
3772 Activate(-1);
3773 break;
3774 case RC_REMOVE:
3775 RemCanvas();
3776 Activate(-1);
3777 break;
3778 case RC_ONLY:
3779 OneCanvas();
3780 Activate(-1);
3781 break;
3782 case RC_FIT:
3783 D_forecv->c_xoff = D_forecv->c_xs;
3784 D_forecv->c_yoff = D_forecv->c_ys;
3785 RethinkViewportOffsets(D_forecv);
3786 ResizeLayer(D_forecv->c_layer, D_forecv->c_xe - D_forecv->c_xs + 1, D_forecv->c_ye - D_forecv->c_ys + 1, 0);
3787 flayer = D_forecv->c_layer;
3788 LaySetCursor();
3789 break;
3790 case RC_FOCUS:
3791 if (!*args || !strcmp(*args, "down"))
3792 D_forecv = D_forecv->c_next ? D_forecv->c_next : D_cvlist;
3793 else if (!strcmp(*args, "up"))
3794 {
3795 struct canvas *cv;
3796 for (cv = D_cvlist; cv->c_next && cv->c_next != D_forecv; cv = cv->c_next)
3797 ;
3798 D_forecv = cv;
3799 }
3800 else if (!strcmp(*args, "top"))
3801 D_forecv = D_cvlist;
3802 else if (!strcmp(*args, "bottom"))
3803 {
3804 struct canvas *cv;
3805 for (cv = D_cvlist; cv->c_next; cv = cv->c_next)
3806 ;
3807 D_forecv = cv;
3808 }
3809 else
3810 {
3811 Msg(0, "%s: usage: focus [up|down|top|bottom]", rc_name);
3812 break;
3813 }
3814 if ((focusminwidth && (focusminwidth < 0 || D_forecv->c_xe - D_forecv->c_xs + 1 < focusminwidth)) ||
3815 (focusminheight && (focusminheight < 0 || D_forecv->c_ye - D_forecv->c_ys + 1 < focusminheight)))
3816 {
3817 ResizeCanvas(&D_canvas);
3818 RecreateCanvasChain();
3819 RethinkDisplayViewports();
3820 ResizeLayersToCanvases(); /* redisplays */
3821 }
3822 fore = D_fore = Layer2Window(D_forecv->c_layer);
3823 flayer = D_forecv->c_layer;
3824 #ifdef RXVT_OSC
3825 if (D_xtermosc[2] || D_xtermosc[3])
3826 {
3827 Activate(-1);
3828 break;
3829 }
3830 #endif
3831 RefreshHStatus();
3832 #ifdef RXVT_OSC
3833 RefreshXtermOSC();
3834 #endif
3835 flayer = D_forecv->c_layer;
3836 CV_CALL(D_forecv, LayRestore();LaySetCursor());
3837 WindowChanged(0, 'F');
3838 break;
3839 case RC_RESIZE:
3840 i = 0;
3841 if (D_forecv->c_slorient == SLICE_UNKN)
3842 {
3843 Msg(0, "resize: need more than one region");
3844 break;
3845 }
3846 for (; *args; args++)
3847 {
3848 if (!strcmp(*args, "-h"))
3849 i |= RESIZE_FLAG_H;
3850 else if (!strcmp(*args, "-v"))
3851 i |= RESIZE_FLAG_V;
3852 else if (!strcmp(*args, "-b"))
3853 i |= RESIZE_FLAG_H | RESIZE_FLAG_V;
3854 else if (!strcmp(*args, "-p"))
3855 i |= D_forecv->c_slorient == SLICE_VERT ? RESIZE_FLAG_H : RESIZE_FLAG_V;
3856 else if (!strcmp(*args, "-l"))
3857 i |= RESIZE_FLAG_L;
3858 else
3859 break;
3860 }
3861 if (*args && args[1])
3862 {
3863 Msg(0, "%s: usage: resize [-h] [-v] [-l] [num]\n", rc_name);
3864 break;
3865 }
3866 if (*args)
3867 ResizeRegions(*args, i);
3868 else
3869 Input(resizeprompts[i], 20, INP_EVERY, ResizeFin, (char*)0, i);
3870 break;
3871 case RC_SETSID:
3872 (void)ParseSwitch(act, &separate_sids);
3873 break;
3874 case RC_EVAL:
3875 args = SaveArgs(args);
3876 for (i = 0; args[i]; i++)
3877 {
3878 if (args[i][0])
3879 Colonfin(args[i], strlen(args[i]), (char *)0);
3880 free(args[i]);
3881 }
3882 free(args);
3883 break;
3884 case RC_ALTSCREEN:
3885 (void)ParseSwitch(act, &use_altscreen);
3886 if (msgok)
3887 Msg(0, "Will %sdo alternate screen switching", use_altscreen ? "" : "not ");
3888 break;
3889 case RC_MAXWIN:
3890 if (ParseNum(act, &n))
3891 break;
3892 if (n < 1)
3893 Msg(0, "illegal maxwin number specified");
3894 else if (n > maxwin)
3895 Msg(0, "may only decrease maxwin number");
3896 else
3897 maxwin = n;
3898 break;
3899 case RC_BACKTICK:
3900 if (ParseBase(act, *args, &n, 10, "decimal"))
3901 break;
3902 if (!args[1])
3903 setbacktick(n, 0, 0, (char **)0);
3904 else
3905 {
3906 int lifespan, tick;
3907 if (argc < 4)
3908 {
3909 Msg(0, "%s: usage: backtick num [lifespan tick cmd args...]", rc_name);
3910 break;
3911 }
3912 if (ParseBase(act, args[1], &lifespan, 10, "decimal"))
3913 break;
3914 if (ParseBase(act, args[2], &tick, 10, "decimal"))
3915 break;
3916 setbacktick(n, lifespan, tick, SaveArgs(args + 3));
3917 }
3918 WindowChanged(0, '`');
3919 break;
3920 case RC_BLANKER:
3921 #ifdef BLANKER_PRG
3922 if (blankerprg)
3923 {
3924 RunBlanker(blankerprg);
3925 break;
3926 }
3927 #endif
3928 ClearAll();
3929 CursorVisibility(-1);
3930 D_blocked = 4;
3931 break;
3932 #ifdef BLANKER_PRG
3933 case RC_BLANKERPRG:
3934 if (blankerprg)
3935 {
3936 char **pp;
3937 for (pp = blankerprg; *pp; pp++)
3938 free(*pp);
3939 free(blankerprg);
3940 blankerprg = 0;
3941 }
3942 if (args[0][0])
3943 blankerprg = SaveArgs(args);
3944 break;
3945 #endif
3946 case RC_IDLE:
3947 if (*args)
3948 {
3949 struct display *olddisplay = display;
3950 if (!strcmp(*args, "off"))
3951 idletimo = 0;
3952 else if (args[0][0])
3953 idletimo = atoi(*args) * 1000;
3954 if (argc > 1)
3955 {
3956 if ((i = FindCommnr(args[1])) == RC_ILLEGAL)
3957 {
3958 Msg(0, "%s: idle: unknown command '%s'", rc_name, args[1]);
3959 break;
3960 }
3961 if (CheckArgNum(i, args + 2) < 0)
3962 break;
3963 ClearAction(&idleaction);
3964 SaveAction(&idleaction, i, args + 2, argl + 2);
3965 }
3966 for (display = displays; display; display = display->d_next)
3967 ResetIdle();
3968 display = olddisplay;
3969 }
3970 if (msgok)
3971 {
3972 if (idletimo)
3973 Msg(0, "idle timeout %ds, %s", idletimo / 1000, comms[idleaction.nr].name);
3974 else
3975 Msg(0, "idle off");
3976 }
3977 break;
3978 case RC_FOCUSMINSIZE:
3979 for (i = 0; i < 2 && args[i]; i++)
3980 {
3981 if (!strcmp(args[i], "max") || !strcmp(args[i], "_"))
3982 n = -1;
3983 else
3984 n = atoi(args[i]);
3985 if (i == 0)
3986 focusminwidth = n;
3987 else
3988 focusminheight = n;
3989 }
3990 if (msgok)
3991 {
3992 char b[2][20];
3993 for (i = 0; i < 2; i++)
3994 {
3995 n = i == 0 ? focusminwidth : focusminheight;
3996 if (n == -1)
3997 strcpy(b[i], "max");
3998 else
3999 sprintf(b[i], "%d", n);
4000 }
4001 Msg(0, "focus min size is %s %s\n", b[0], b[1]);
4002 }
4003 break;
4004 case RC_GROUP:
4005 if (*args)
4006 {
4007 fore->w_group = 0;
4008 if (args[0][0])
4009 {
4010 fore->w_group = WindowByName(*args);
4011 if (fore->w_group && fore->w_group->w_type != W_TYPE_GROUP)
4012 fore->w_group = 0;
4013 }
4014 WindowChanged((struct win *)0, 'w');
4015 WindowChanged((struct win *)0, 'W');
4016 WindowChanged((struct win *)0, 0);
4017 }
4018 if (msgok)
4019 {
4020 if (fore->w_group)
4021 Msg(0, "window group is %d (%s)\n", fore->w_group->w_number, fore->w_group->w_title);
4022 else
4023 Msg(0, "window belongs to no group");
4024 }
4025 break;
4026 case RC_LAYOUT:
4027 if (!strcmp(args[0], "title"))
4028 {
4029 if (!D_layout)
4030 {
4031 Msg(0, "not on a layout");
4032 break;
4033 }
4034 if (!args[1])
4035 {
4036 Msg(0, "current layout is %d (%s)", D_layout->lay_number, D_layout->lay_title);
4037 break;
4038 }
4039 free(D_layout->lay_title);
4040 D_layout->lay_title= SaveStr(args[1]);
4041 }
4042 else if (!strcmp(args[0], "number"))
4043 {
4044 int old;
4045 struct layout *lay;
4046 if (!args[1])
4047 {
4048 Msg(0, "This is layout %d (%s).\n", D_layout->lay_number, D_layout->lay_title);
4049 break;
4050 }
4051 old = D_layout->lay_number;
4052 n = atoi(args[1]);
4053 if (n < 0 || n >= MAXLAY)
4054 break;
4055 lay = laytab[n];
4056 laytab[n] = D_layout;
4057 D_layout->lay_number = n;
4058 laytab[old] = lay;
4059 if (lay)
4060 lay->lay_number = old;
4061 break;
4062 }
4063 else if (!strcmp(args[0], "autosave"))
4064 {
4065 if (!D_layout)
4066 {
4067 Msg(0, "not on a layout");
4068 break;
4069 }
4070 if (args[1])
4071 {
4072 if (!strcmp(args[1], "on"))
4073 D_layout->lay_autosave = 1;
4074 else if (!strcmp(args[1], "off"))
4075 D_layout->lay_autosave = 0;
4076 else
4077 {
4078 Msg(0, "invalid argument. Give 'on' or 'off");
4079 break;
4080 }
4081 }
4082 if (msgok)
4083 Msg(0, "autosave is %s", D_layout->lay_autosave ? "on" : "off");
4084 }
4085 else if (!strcmp(args[0], "new"))
4086 {
4087 char *t = args[1];
4088 n = 0;
4089 if (t)
4090 {
4091 while (*t >= '0' && *t <= '9')
4092 t++;
4093 if (t != args[1] && (!*t || *t == ':'))
4094 {
4095 n = atoi(args[1]);
4096 if (*t)
4097 t++;
4098 }
4099 else
4100 t = args[1];
4101 }
4102 if (!t || !*t)
4103 t = "layout";
4104 NewLayout(t, n);
4105 Activate(-1);
4106 }
4107 else if (!strcmp(args[0], "save"))
4108 {
4109 if (!args[1])
4110 {
4111 Msg(0, "usage: layout save <name>");
4112 break;
4113 }
4114 SaveLayout(args[1], &D_canvas);
4115 }
4116 else if (!strcmp(args[0], "select"))
4117 {
4118 if (!args[1])
4119 {
4120 Input("Switch to layout: ", 20, INP_COOKED, SelectLayoutFin, NULL, 0);
4121 break;
4122 }
4123 SelectLayoutFin(args[1], strlen(args[1]), (char *)0);
4124 }
4125 else if (!strcmp(args[0], "next"))
4126 {
4127 struct layout *lay = D_layout;
4128 if (lay)
4129 lay = lay->lay_next ? lay->lay_next : layouts;
4130 else
4131 lay = layouts;
4132 if (!lay)
4133 {
4134 Msg(0, "no layout defined");
4135 break;
4136 }
4137 if (lay == D_layout)
4138 break;
4139 LoadLayout(lay, &D_canvas);
4140 Activate(-1);
4141 }
4142 else if (!strcmp(args[0], "prev"))
4143 {
4144 struct layout *lay = D_layout;
4145 if (lay)
4146 {
4147 for (lay = layouts; lay->lay_next && lay->lay_next != D_layout; lay = lay->lay_next)
4148 ;
4149 }
4150 else
4151 lay = layouts;
4152 if (!lay)
4153 {
4154 Msg(0, "no layout defined");
4155 break;
4156 }
4157 if (lay == D_layout)
4158 break;
4159 LoadLayout(lay, &D_canvas);
4160 Activate(-1);
4161 }
4162 else if (!strcmp(args[0], "attach"))
4163 {
4164 if (!args[1])
4165 {
4166 if (!layout_attach)
4167 Msg(0, "no attach layout set");
4168 else if (layout_attach == &layout_last_marker)
4169 Msg(0, "will attach to last layout");
4170 else
4171 Msg(0, "will attach to layout %d (%s)", layout_attach->lay_number, layout_attach->lay_title);
4172 break;
4173 }
4174 if (!strcmp(args[1], ":last"))
4175 layout_attach = &layout_last_marker;
4176 else if (!args[1][0])
4177 layout_attach = 0;
4178 else
4179 {
4180 struct layout *lay;
4181 lay = FindLayout(args[1]);
4182 if (!lay)
4183 {
4184 Msg(0, "unknown layout '%s'", args[1]);
4185 break;
4186 }
4187 layout_attach = lay;
4188 }
4189 }
4190 else if (!strcmp(args[0], "show"))
4191 {
4192 ShowLayouts(-1);
4193 }
4194 else
4195 Msg(0, "unknown layout subcommand");
4196 break;
4197 #ifdef DW_CHARS
4198 case RC_CJKWIDTH:
4199 if(ParseSwitch(act, &cjkwidth) == 0)
4200 {
4201 if(msgok)
4202 Msg(0, "Treat ambiguous width characters as %s width", cjkwidth ? "full" : "half");
4203 }
4204 break;
4205 #endif
4206 default:
4207 #ifdef HAVE_BRAILLE
4208 /* key == -2: input from braille keybord, msgok always 0 */
4209 DoBrailleAction(act, key == -2 ? 0 : msgok);
4210 #endif
4211 break;
4212 }
4213 if (display != odisplay)
4214 {
4215 for (display = displays; display; display = display->d_next)
4216 if (display == odisplay)
4217 break;
4218 }
4219 }
4220
4221 void
4222 DoCommand(argv, argl)
4223 char **argv;
4224 int *argl;
4225 {
4226 struct action act;
4227
4228 if ((act.nr = FindCommnr(*argv)) == RC_ILLEGAL)
4229 {
4230 Msg(0, "%s: unknown command '%s'", rc_name, *argv);
4231 return;
4232 }
4233 act.args = argv + 1;
4234 act.argl = argl + 1;
4235 DoAction(&act, -1);
4236 }
4237
4238 static void
4239 SaveAction(act, nr, args, argl)
4240 struct action *act;
4241 int nr;
4242 char **args;
4243 int *argl;
4244 {
4245 register int argc = 0;
4246 char **pp;
4247 int *lp;
4248
4249 if (args)
4250 while (args[argc])
4251 argc++;
4252 if (argc == 0)
4253 {
4254 act->nr = nr;
4255 act->args = noargs;
4256 act->argl = 0;
4257 return;
4258 }
4259 if ((pp = (char **)malloc((unsigned)(argc + 1) * sizeof(char **))) == 0)
4260 Panic(0, strnomem);
4261 if ((lp = (int *)malloc((unsigned)(argc) * sizeof(int *))) == 0)
4262 Panic(0, strnomem);
4263 act->nr = nr;
4264 act->args = pp;
4265 act->argl = lp;
4266 while (argc--)
4267 {
4268 *lp = argl ? *argl++ : (int)strlen(*args);
4269 *pp++ = SaveStrn(*args++, *lp++);
4270 }
4271 *pp = 0;
4272 }
4273
4274 static char **
4275 SaveArgs(args)
4276 char **args;
4277 {
4278 register char **ap, **pp;
4279 register int argc = 0;
4280
4281 while (args[argc])
4282 argc++;
4283 if ((pp = ap = (char **)malloc((unsigned)(argc + 1) * sizeof(char **))) == 0)
4284 Panic(0, strnomem);
4285 while (argc--)
4286 *pp++ = SaveStr(*args++);
4287 *pp = 0;
4288 return ap;
4289 }
4290
4291
4292 /*
4293 * buf is split into argument vector args.
4294 * leading whitespace is removed.
4295 * @!| abbreviations are expanded.
4296 * the end of buffer is recognized by '\0' or an un-escaped '#'.
4297 * " and ' are interpreted.
4298 *
4299 * argc is returned.
4300 */
4301 int
4302 Parse(buf, bufl, args, argl)
4303 char *buf, **args;
4304 int bufl, *argl;
4305 {
4306 register char *p = buf, **ap = args, *pp;
4307 register int delim, argc;
4308 int *lp = argl;
4309
4310 debug2("Parse %d %s\n", bufl, buf);
4311 argc = 0;
4312 pp = buf;
4313 delim = 0;
4314 for (;;)
4315 {
4316 while (*p && (*p == ' ' || *p == '\t'))
4317 ++p;
4318 #ifdef PSEUDOS
4319 if (argc == 0 && *p == '!')
4320 {
4321 *ap++ = "exec";
4322 *lp++ = 4;
4323 p++;
4324 argc++;
4325 continue;
4326 }
4327 #endif
4328 if (*p == '\0' || *p == '#' || *p == '\n')
4329 {
4330 *p = '\0';
4331 for (delim = 0; delim < argc; delim++)
4332 debug1("-- %s\n", args[delim]);
4333 args[argc] = 0;
4334 return argc;
4335 }
4336 if (++argc >= MAXARGS)
4337 {
4338 Msg(0, "%s: too many tokens.", rc_name);
4339 return 0;
4340 }
4341 *ap++ = pp;
4342
4343 debug1("- new arg %s\n", p);
4344 while (*p)
4345 {
4346 if (*p == delim)
4347 delim = 0;
4348 else if (delim != '\'' && *p == '\\' && (p[1] == '\'' || p[1] == '"' || p[1] == '\\' || p[1] == '$' || p[1] == '#' || p[1] == '^' || (p[1] >= '0' && p[1] <= '7')))
4349 {
4350 p++;
4351 if (*p >= '0' && *p <= '7')
4352 {
4353 *pp = *p - '0';
4354 if (p[1] >= '0' && p[1] <= '7')
4355 {
4356 p++;
4357 *pp = (*pp << 3) | (*p - '0');
4358 if (p[1] >= '0' && p[1] <= '7')
4359 {
4360 p++;
4361 *pp = (*pp << 3) | (*p - '0');
4362 }
4363 }
4364 pp++;
4365 }
4366 else
4367 *pp++ = *p;
4368 }
4369 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] == '_'))
4370
4371 {
4372 char *ps, *pe, op, *v, xbuf[11];
4373 int vl;
4374
4375 ps = ++p;
4376 debug1("- var %s\n", ps);
4377 p++;
4378 while (*p)
4379 {
4380 if (*ps == '{' && *p == '}')
4381 break;
4382 if (*ps == ':' && *p == ':')
4383 break;
4384 if (*ps != '{' && *ps != ':' && (*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z') && (*p < '0' || *p > '9') && *p != '_')
4385 break;
4386 p++;
4387 }
4388 pe = p;
4389 if (*ps == '{' || *ps == ':')
4390 {
4391 if (!*p)
4392 {
4393 Msg(0, "%s: bad variable name.", rc_name);
4394 return 0;
4395 }
4396 p++;
4397 }
4398 op = *pe;
4399 *pe = 0;
4400 debug1("- var is '%s'\n", ps);
4401 if (*ps == ':')
4402 v = gettermcapstring(ps + 1);
4403 else
4404 {
4405 if (*ps == '{')
4406 ps++;
4407 v = xbuf;
4408 if (!strcmp(ps, "TERM"))
4409 v = display ? D_termname : "unknown";
4410 else if (!strcmp(ps, "COLUMNS"))
4411 sprintf(xbuf, "%d", display ? D_width : -1);
4412 else if (!strcmp(ps, "LINES"))
4413 sprintf(xbuf, "%d", display ? D_height : -1);
4414 else
4415 v = getenv(ps);
4416 }
4417 *pe = op;
4418 vl = v ? strlen(v) : 0;
4419 if (vl)
4420 {
4421 debug1("- sub is '%s'\n", v);
4422 if (p - pp < vl)
4423 {
4424 int right = buf + bufl - (p + strlen(p) + 1);
4425 if (right > 0)
4426 {
4427 bcopy(p, p + right, strlen(p) + 1);
4428 p += right;
4429 }
4430 }
4431 if (p - pp < vl)
4432 {
4433 Msg(0, "%s: no space left for variable expansion.", rc_name);
4434 return 0;
4435 }
4436 bcopy(v, pp, vl);
4437 pp += vl;
4438 }
4439 continue;
4440 }
4441 else if (delim != '\'' && *p == '^' && p[1])
4442 {
4443 p++;
4444 *pp++ = *p == '?' ? '\177' : *p & 0x1f;
4445 }
4446 else if (delim == 0 && (*p == '\'' || *p == '"'))
4447 delim = *p;
4448 else if (delim == 0 && (*p == ' ' || *p == '\t' || *p == '\n'))
4449 break;
4450 else
4451 *pp++ = *p;
4452 p++;
4453 }
4454 if (delim)
4455 {
4456 Msg(0, "%s: Missing %c quote.", rc_name, delim);
4457 return 0;
4458 }
4459 if (*p)
4460 p++;
4461 *pp = 0;
4462 debug2("- arg done, '%s' rest %s\n", ap[-1], p);
4463 *lp++ = pp - ap[-1];
4464 pp++;
4465 }
4466 }
4467
4468 void
4469 SetEscape(u, e, me)
4470 struct acluser *u;
4471 int e, me;
4472 {
4473 if (u)
4474 {
4475 u->u_Esc = e;
4476 u->u_MetaEsc = me;
4477 }
4478 else
4479 {
4480 if (users)
4481 {
4482 if (DefaultEsc >= 0)
4483 ClearAction(&ktab[DefaultEsc]);
4484 if (DefaultMetaEsc >= 0)
4485 ClearAction(&ktab[DefaultMetaEsc]);
4486 }
4487 DefaultEsc = e;
4488 DefaultMetaEsc = me;
4489 if (users)
4490 {
4491 if (DefaultEsc >= 0)
4492 {
4493 ClearAction(&ktab[DefaultEsc]);
4494 ktab[DefaultEsc].nr = RC_OTHER;
4495 }
4496 if (DefaultMetaEsc >= 0)
4497 {
4498 ClearAction(&ktab[DefaultMetaEsc]);
4499 ktab[DefaultMetaEsc].nr = RC_META;
4500 }
4501 }
4502 }
4503 }
4504
4505 int
4506 ParseSwitch(act, var)
4507 struct action *act;
4508 int *var;
4509 {
4510 if (*act->args == 0)
4511 {
4512 *var ^= 1;
4513 return 0;
4514 }
4515 return ParseOnOff(act, var);
4516 }
4517
4518 static int
4519 ParseOnOff(act, var)
4520 struct action *act;
4521 int *var;
4522 {
4523 register int num = -1;
4524 char **args = act->args;
4525
4526 if (args[1] == 0)
4527 {
4528 if (strcmp(args[0], "on") == 0)
4529 num = 1;
4530 else if (strcmp(args[0], "off") == 0)
4531 num = 0;
4532 }
4533 if (num < 0)
4534 {
4535 Msg(0, "%s: %s: invalid argument. Give 'on' or 'off'", rc_name, comms[act->nr].name);
4536 return -1;
4537 }
4538 *var = num;
4539 return 0;
4540 }
4541
4542 int
4543 ParseSaveStr(act, var)
4544 struct action *act;
4545 char **var;
4546 {
4547 char **args = act->args;
4548 if (*args == 0 || args[1])
4549 {
4550 Msg(0, "%s: %s: one argument required.", rc_name, comms[act->nr].name);
4551 return -1;
4552 }
4553 if (*var)
4554 free(*var);
4555 *var = SaveStr(*args);
4556 return 0;
4557 }
4558
4559 int
4560 ParseNum(act, var)
4561 struct action *act;
4562 int *var;
4563 {
4564 int i;
4565 char *p, **args = act->args;
4566
4567 p = *args;
4568 if (p == 0 || *p == 0 || args[1])
4569 {
4570 Msg(0, "%s: %s: invalid argument. Give one argument.",
4571 rc_name, comms[act->nr].name);
4572 return -1;
4573 }
4574 i = 0;
4575 while (*p)
4576 {
4577 if (*p >= '0' && *p <= '9')
4578 i = 10 * i + (*p - '0');
4579 else
4580 {
4581 Msg(0, "%s: %s: invalid argument. Give numeric argument.",
4582 rc_name, comms[act->nr].name);
4583 return -1;
4584 }
4585 p++;
4586 }
4587 debug1("ParseNum got %d\n", i);
4588 *var = i;
4589 return 0;
4590 }
4591
4592 static int
4593 ParseNum1000(act, var)
4594 struct action *act;
4595 int *var;
4596 {
4597 int i;
4598 char *p, **args = act->args;
4599 int dig = 0;
4600
4601 p = *args;
4602 if (p == 0 || *p == 0 || args[1])
4603 {
4604 Msg(0, "%s: %s: invalid argument. Give one argument.",
4605 rc_name, comms[act->nr].name);
4606 return -1;
4607 }
4608 i = 0;
4609 while (*p)
4610 {
4611 if (*p >= '0' && *p <= '9')
4612 {
4613 if (dig < 4)
4614 i = 10 * i + (*p - '0');
4615 else if (dig == 4 && *p >= '5')
4616 i++;
4617 if (dig)
4618 dig++;
4619 }
4620 else if (*p == '.' && !dig)
4621 dig++;
4622 else
4623 {
4624 Msg(0, "%s: %s: invalid argument. Give floating point argument.",
4625 rc_name, comms[act->nr].name);
4626 return -1;
4627 }
4628 p++;
4629 }
4630 if (dig == 0)
4631 i *= 1000;
4632 else
4633 while (dig++ < 4)
4634 i *= 10;
4635 if (i < 0)
4636 i = (int)((unsigned int)~0 >> 1);
4637 debug1("ParseNum1000 got %d\n", i);
4638 *var = i;
4639 return 0;
4640 }
4641
4642 static struct win *
4643 WindowByName(s)
4644 char *s;
4645 {
4646 struct win *p;
4647
4648 for (p = windows; p; p = p->w_next)
4649 if (!strcmp(p->w_title, s))
4650 return p;
4651 for (p = windows; p; p = p->w_next)
4652 if (!strncmp(p->w_title, s, strlen(s)))
4653 return p;
4654 return 0;
4655 }
4656
4657 static int
4658 WindowByNumber(str)
4659 char *str;
4660 {
4661 int i;
4662 char *s;
4663
4664 for (i = 0, s = str; *s; s++)
4665 {
4666 if (*s < '0' || *s > '9')
4667 break;
4668 i = i * 10 + (*s - '0');
4669 }
4670 return *s ? -1 : i;
4671 }
4672
4673 /*
4674 * Get window number from Name or Number string.
4675 * Numbers are tried first, then names, a prefix match suffices.
4676 * Be careful when assigning numeric strings as WindowTitles.
4677 */
4678 int
4679 WindowByNoN(str)
4680 char *str;
4681 {
4682 int i;
4683 struct win *p;
4684
4685 if ((i = WindowByNumber(str)) < 0 || i >= MAXWIN)
4686 {
4687 if ((p = WindowByName(str)))
4688 return p->w_number;
4689 return -1;
4690 }
4691 return i;
4692 }
4693
4694 static int
4695 ParseWinNum(act, var)
4696 struct action *act;
4697 int *var;
4698 {
4699 char **args = act->args;
4700 int i = 0;
4701
4702 if (*args == 0 || args[1])
4703 {
4704 Msg(0, "%s: %s: one argument required.", rc_name, comms[act->nr].name);
4705 return -1;
4706 }
4707
4708 i = WindowByNoN(*args);
4709 if (i < 0)
4710 {
4711 Msg(0, "%s: %s: invalid argument. Give window number or name.",
4712 rc_name, comms[act->nr].name);
4713 return -1;
4714 }
4715 debug1("ParseWinNum got %d\n", i);
4716 *var = i;
4717 return 0;
4718 }
4719
4720 static int
4721 ParseBase(act, p, var, base, bname)
4722 struct action *act;
4723 char *p;
4724 int *var;
4725 int base;
4726 char *bname;
4727 {
4728 int i = 0;
4729 int c;
4730
4731 if (*p == 0)
4732 {
4733 Msg(0, "%s: %s: empty argument.", rc_name, comms[act->nr].name);
4734 return -1;
4735 }
4736 while ((c = *p++))
4737 {
4738 if (c >= 'a' && c <= 'z')
4739 c -= 'a' - 'A';
4740 if (c >= 'A' && c <= 'Z')
4741 c -= 'A' - ('0' + 10);
4742 c -= '0';
4743 if (c < 0 || c >= base)
4744 {
4745 Msg(0, "%s: %s: argument is not %s.", rc_name, comms[act->nr].name, bname);
4746 return -1;
4747 }
4748 i = base * i + c;
4749 }
4750 debug1("ParseBase got %d\n", i);
4751 *var = i;
4752 return 0;
4753 }
4754
4755 static int
4756 IsNum(s, base)
4757 register char *s;
4758 register int base;
4759 {
4760 for (base += '0'; *s; ++s)
4761 if (*s < '0' || *s > base)
4762 return 0;
4763 return 1;
4764 }
4765
4766 int
4767 IsNumColon(s, base, p, psize)
4768 int base, psize;
4769 char *s, *p;
4770 {
4771 char *q;
4772 if ((q = rindex(s, ':')) != 0)
4773 {
4774 strncpy(p, q + 1, psize - 1);
4775 p[psize - 1] = '\0';
4776 *q = '\0';
4777 }
4778 else
4779 *p = '\0';
4780 return IsNum(s, base);
4781 }
4782
4783 void
4784 SwitchWindow(n)
4785 int n;
4786 {
4787 struct win *p;
4788
4789 debug1("SwitchWindow %d\n", n);
4790 if (n < 0 || n >= MAXWIN)
4791 {
4792 ShowWindows(-1);
4793 return;
4794 }
4795 if ((p = wtab[n]) == 0)
4796 {
4797 ShowWindows(n);
4798 return;
4799 }
4800 if (display == 0)
4801 {
4802 fore = p;
4803 return;
4804 }
4805 if (p == D_fore)
4806 {
4807 Msg(0, "This IS window %d (%s).", n, p->w_title);
4808 return;
4809 }
4810 #ifdef MULTIUSER
4811 if (AclCheckPermWin(D_user, ACL_READ, p))
4812 {
4813 Msg(0, "Access to window %d denied.", p->w_number);
4814 return;
4815 }
4816 #endif
4817 SetForeWindow(p);
4818 Activate(fore->w_norefresh);
4819 }
4820
4821
4822 void
4823 SetCanvasWindow(cv, wi)
4824 struct canvas *cv;
4825 struct win *wi;
4826 {
4827 struct win *p = 0, **pp;
4828 struct layer *l;
4829 struct canvas *cvp, **cvpp;
4830
4831 l = cv->c_layer;
4832 display = cv->c_display;
4833
4834 if (l)
4835 {
4836 /* remove old layer */
4837 for (cvpp = &l->l_cvlist; (cvp = *cvpp); cvpp = &cvp->c_lnext)
4838 if (cvp == cv)
4839 break;
4840 ASSERT(cvp);
4841 *cvpp = cvp->c_lnext;
4842
4843 p = Layer2Window(l);
4844 l = cv->c_layer;
4845 cv->c_layer = 0;
4846
4847 if (p && cv == D_forecv)
4848 {
4849 #ifdef MULTIUSER
4850 ReleaseAutoWritelock(display, p);
4851 #endif
4852 if (p->w_silence)
4853 {
4854 SetTimeout(&p->w_silenceev, p->w_silencewait * 1000);
4855 evenq(&p->w_silenceev);
4856 }
4857 D_other = fore;
4858 D_fore = 0;
4859 }
4860 if (l->l_cvlist == 0 && (p == 0 || l != p->w_savelayer))
4861 KillLayerChain(l);
4862 }
4863
4864 /* find right layer to display on canvas */
4865 if (wi && wi->w_type != W_TYPE_GROUP)
4866 {
4867 l = &wi->w_layer;
4868 if (wi->w_savelayer && (wi->w_blocked || wi->w_savelayer->l_cvlist == 0))
4869 l = wi->w_savelayer;
4870 }
4871 else
4872 {
4873 l = &cv->c_blank;
4874 if (wi)
4875 l->l_data = (char *)wi;
4876 else
4877 l->l_data = 0;
4878 }
4879
4880 /* add our canvas to the layer's canvaslist */
4881 ASSERT(l->l_cvlist != cv);
4882 cv->c_lnext = l->l_cvlist;
4883 l->l_cvlist = cv;
4884 cv->c_layer = l;
4885 cv->c_xoff = cv->c_xs;
4886 cv->c_yoff = cv->c_ys;
4887 RethinkViewportOffsets(cv);
4888
4889 if (flayer == 0)
4890 flayer = l;
4891
4892 if (wi && wi->w_type == W_TYPE_GROUP)
4893 {
4894 /* auto-start windowlist on groups */
4895 struct display *d = display;
4896 struct layer *oldflayer = flayer;
4897 flayer = l;
4898 display_wlist(0, 0, wi);
4899 flayer = oldflayer;
4900 display = d;
4901 }
4902
4903 if (wi && D_other == wi)
4904 D_other = wi->w_next; /* Might be 0, but that's OK. */
4905 if (cv == D_forecv)
4906 {
4907 D_fore = wi;
4908 fore = D_fore; /* XXX ? */
4909 if (wi)
4910 {
4911 #ifdef MULTIUSER
4912 ObtainAutoWritelock(display, wi);
4913 #endif
4914 /*
4915 * Place the window at the head of the most-recently-used list
4916 */
4917 if (windows != wi)
4918 {
4919 for (pp = &windows; (p = *pp); pp = &p->w_next)
4920 if (p == wi)
4921 break;
4922 ASSERT(p);
4923 *pp = p->w_next;
4924 p->w_next = windows;
4925 windows = p;
4926 WListLinkChanged();
4927 }
4928 }
4929 }
4930 }
4931
4932
4933 /*
4934 * SetForeWindow changes the window in the input focus of the display.
4935 * Puts window wi in canvas display->d_forecv.
4936 */
4937 void
4938 SetForeWindow(wi)
4939 struct win *wi;
4940 {
4941 struct win *p;
4942 if (display == 0)
4943 {
4944 fore = wi;
4945 return;
4946 }
4947 p = Layer2Window(D_forecv->c_layer);
4948 SetCanvasWindow(D_forecv, wi);
4949 if (p)
4950 WindowChanged(p, 'u');
4951 if (wi)
4952 WindowChanged(wi, 'u');
4953 flayer = D_forecv->c_layer;
4954 /* Activate called afterwards, so no RefreshHStatus needed */
4955 }
4956
4957
4958 /*****************************************************************/
4959
4960 /*
4961 * Activate - make fore window active
4962 * norefresh = -1 forces a refresh, disregard all_norefresh then.
4963 */
4964 void
4965 Activate(norefresh)
4966 int norefresh;
4967 {
4968 debug1("Activate(%d)\n", norefresh);
4969 if (display == 0)
4970 return;
4971 if (D_status)
4972 {
4973 Msg(0, "%s", ""); /* wait till mintime (keep gcc quiet) */
4974 RemoveStatus();
4975 }
4976
4977 if (MayResizeLayer(D_forecv->c_layer))
4978 ResizeLayer(D_forecv->c_layer, D_forecv->c_xe - D_forecv->c_xs + 1, D_forecv->c_ye - D_forecv->c_ys + 1, display);
4979
4980 fore = D_fore;
4981 if (fore)
4982 {
4983 /* XXX ? */
4984 if (fore->w_monitor != MON_OFF)
4985 fore->w_monitor = MON_ON;
4986 fore->w_bell = BELL_ON;
4987 WindowChanged(fore, 'f');
4988
4989 #if 0
4990 if (ResizeDisplay(fore->w_width, fore->w_height))
4991 {
4992 debug2("Cannot resize from (%d,%d)", D_width, D_height);
4993 debug2(" to (%d,%d) -> resize window\n", fore->w_width, fore->w_height);
4994 DoResize(D_width, D_height);
4995 }
4996 #endif
4997 }
4998 Redisplay(norefresh + all_norefresh);
4999 }
5000
5001
5002 static int
5003 NextWindow()
5004 {
5005 register struct win **pp;
5006 int n = fore ? fore->w_number : MAXWIN;
5007 struct win *group = fore ? fore->w_group : 0;
5008
5009 for (pp = fore ? wtab + n + 1 : wtab; pp != wtab + n; pp++)
5010 {
5011 if (pp == wtab + MAXWIN)
5012 pp = wtab;
5013 if (*pp)
5014 {
5015 if (!fore || group == (*pp)->w_group)
5016 break;
5017 }
5018 }
5019 if (pp == wtab + n)
5020 return -1;
5021 return pp - wtab;
5022 }
5023
5024 static int
5025 PreviousWindow()
5026 {
5027 register struct win **pp;
5028 int n = fore ? fore->w_number : -1;
5029 struct win *group = fore ? fore->w_group : 0;
5030
5031 for (pp = wtab + n - 1; pp != wtab + n; pp--)
5032 {
5033 if (pp == wtab - 1)
5034 pp = wtab + MAXWIN - 1;
5035 if (*pp)
5036 {
5037 if (!fore || group == (*pp)->w_group)
5038 break;
5039 }
5040 }
5041 if (pp == wtab + n)
5042 return -1;
5043 return pp - wtab;
5044 }
5045
5046 static int
5047 MoreWindows()
5048 {
5049 char *m = "No other window.";
5050 if (windows && (fore == 0 || windows->w_next))
5051 return 1;
5052 if (fore == 0)
5053 {
5054 Msg(0, "No window available");
5055 return 0;
5056 }
5057 Msg(0, m, fore->w_number); /* other arg for nethack */
5058 return 0;
5059 }
5060
5061 void
5062 KillWindow(wi)
5063 struct win *wi;
5064 {
5065 struct win **pp, *p;
5066 struct canvas *cv;
5067 int gotone;
5068
5069 /*
5070 * Remove window from linked list.
5071 */
5072 for (pp = &windows; (p = *pp); pp = &p->w_next)
5073 if (p == wi)
5074 break;
5075 ASSERT(p);
5076 *pp = p->w_next;
5077 wi->w_inlen = 0;
5078 wtab[wi->w_number] = 0;
5079
5080 if (windows == 0)
5081 {
5082 FreeWindow(wi);
5083 Finit(0);
5084 }
5085
5086 /*
5087 * switch to different window on all canvases
5088 */
5089 for (display = displays; display; display = display->d_next)
5090 {
5091 gotone = 0;
5092 for (cv = D_cvlist; cv; cv = cv->c_next)
5093 {
5094 if (Layer2Window(cv->c_layer) != wi)
5095 continue;
5096 /* switch to other window */
5097 SetCanvasWindow(cv, FindNiceWindow(D_other, 0));
5098 gotone = 1;
5099 }
5100 if (gotone)
5101 {
5102 #ifdef ZMODEM
5103 if (wi->w_zdisplay == display)
5104 {
5105 D_blocked = 0;
5106 D_readev.condpos = D_readev.condneg = 0;
5107 }
5108 #endif
5109 Activate(-1);
5110 }
5111 }
5112 FreeWindow(wi);
5113 WindowChanged((struct win *)0, 'w');
5114 WindowChanged((struct win *)0, 'W');
5115 WindowChanged((struct win *)0, 0);
5116 }
5117
5118 static void
5119 LogToggle(on)
5120 int on;
5121 {
5122 char buf[1024];
5123
5124 if ((fore->w_log != 0) == on)
5125 {
5126 if (display && !*rc_name)
5127 Msg(0, "You are %s logging.", on ? "already" : "not");
5128 return;
5129 }
5130 if (fore->w_log != 0)
5131 {
5132 Msg(0, "Logfile \"%s\" closed.", fore->w_log->name);
5133 logfclose(fore->w_log);
5134 fore->w_log = 0;
5135 WindowChanged(fore, 'f');
5136 return;
5137 }
5138 if (DoStartLog(fore, buf, sizeof(buf)))
5139 {
5140 Msg(errno, "Error opening logfile \"%s\"", buf);
5141 return;
5142 }
5143 if (ftell(fore->w_log->fp) == 0)
5144 Msg(0, "Creating logfile \"%s\".", fore->w_log->name);
5145 else
5146 Msg(0, "Appending to logfile \"%s\".", fore->w_log->name);
5147 WindowChanged(fore, 'f');
5148 }
5149
5150 char *
5151 AddWindows(buf, len, flags, where)
5152 char *buf;
5153 int len;
5154 int flags;
5155 int where;
5156 {
5157 register char *s, *ss;
5158 register struct win **pp, *p;
5159 register char *cmd;
5160 int l;
5161
5162 s = ss = buf;
5163 for (pp = ((flags & 4) && where >= 0) ? wtab + where + 1: wtab; pp < wtab + MAXWIN; pp++)
5164 {
5165 if (pp - wtab == where && ss == buf)
5166 ss = s;
5167 if ((p = *pp) == 0)
5168 continue;
5169 if ((flags & 1) && display && p == D_fore)
5170 continue;
5171 if (D_fore && D_fore->w_group != p->w_group)
5172 continue;
5173
5174 cmd = p->w_title;
5175 l = strlen(cmd);
5176 if (l > 20)
5177 l = 20;
5178 if (s - buf + l > len - 24)
5179 break;
5180 if (s > buf || (flags & 4))
5181 {
5182 *s++ = ' ';
5183 *s++ = ' ';
5184 }
5185 sprintf(s, "%d", p->w_number);
5186 if (p->w_number == where)
5187 ss = s;
5188 s += strlen(s);
5189 if (display && p == D_fore)
5190 *s++ = '*';
5191 if (!(flags & 2))
5192 {
5193 if (display && p == D_other)
5194 *s++ = '-';
5195 s = AddWindowFlags(s, len, p);
5196 }
5197 *s++ = ' ';
5198 strncpy(s, cmd, l);
5199 s += l;
5200 }
5201 *s = 0;
5202 return ss;
5203 }
5204
5205 char *
5206 AddWindowFlags(buf, len, p)
5207 char *buf;
5208 int len;
5209 struct win *p;
5210 {
5211 char *s = buf;
5212 if (p == 0 || len < 12)
5213 {
5214 *s = 0;
5215 return s;
5216 }
5217 #if 0
5218 if (display && p == D_fore)
5219 *s++ = '*';
5220 if (display && p == D_other)
5221 *s++ = '-';
5222 #endif
5223 if (p->w_layer.l_cvlist && p->w_layer.l_cvlist->c_lnext)
5224 *s++ = '&';
5225 if (p->w_monitor == MON_DONE
5226 #ifdef MULTIUSER
5227 && (ACLBYTE(p->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id))
5228 #endif
5229 )
5230 *s++ = '@';
5231 if (p->w_bell == BELL_DONE)
5232 *s++ = '!';
5233 #ifdef UTMPOK
5234 if (p->w_slot != (slot_t) 0 && p->w_slot != (slot_t) -1)
5235 *s++ = '$';
5236 #endif
5237 if (p->w_log != 0)
5238 {
5239 strcpy(s, "(L)");
5240 s += 3;
5241 }
5242 if (p->w_ptyfd < 0 && p->w_type != W_TYPE_GROUP)
5243 *s++ = 'Z';
5244 *s = 0;
5245 return s;
5246 }
5247
5248 char *
5249 AddOtherUsers(buf, len, p)
5250 char *buf;
5251 int len;
5252 struct win *p;
5253 {
5254 struct display *d, *olddisplay = display;
5255 struct canvas *cv;
5256 char *s;
5257 int l;
5258
5259 s = buf;
5260 for (display = displays; display; display = display->d_next)
5261 {
5262 if (olddisplay && D_user == olddisplay->d_user)
5263 continue;
5264 for (cv = D_cvlist; cv; cv = cv->c_next)
5265 if (Layer2Window(cv->c_layer) == p)
5266 break;
5267 if (!cv)
5268 continue;
5269 for (d = displays; d && d != display; d = d->d_next)
5270 if (D_user == d->d_user)
5271 break;
5272 if (d && d != display)
5273 continue;
5274 if (len > 1 && s != buf)
5275 {
5276 *s++ = ',';
5277 len--;
5278 }
5279 l = strlen(D_user->u_name);
5280 if (l + 1 > len)
5281 break;
5282 strcpy(s, D_user->u_name);
5283 s += l;
5284 len -= l;
5285 }
5286 *s = 0;
5287 display = olddisplay;
5288 return s;
5289 }
5290
5291 void
5292 ShowWindows(where)
5293 int where;
5294 {
5295 char buf[1024];
5296 char *s, *ss;
5297
5298 if (!display)
5299 return;
5300 if (where == -1 && D_fore)
5301 where = D_fore->w_number;
5302 ss = AddWindows(buf, sizeof(buf), 0, where);
5303 s = buf + strlen(buf);
5304 if (ss - buf > D_width / 2)
5305 {
5306 ss -= D_width / 2;
5307 if (s - ss < D_width)
5308 {
5309 ss = s - D_width;
5310 if (ss < buf)
5311 ss = buf;
5312 }
5313 }
5314 else
5315 ss = buf;
5316 Msg(0, "%s", ss);
5317 }
5318
5319 static void
5320 ShowInfo()
5321 {
5322 char buf[512], *p;
5323 register struct win *wp = fore;
5324 register int i;
5325
5326 if (wp == 0)
5327 {
5328 Msg(0, "(%d,%d)/(%d,%d) no window", D_x + 1, D_y + 1, D_width, D_height);
5329 return;
5330 }
5331 p = buf;
5332 if (buf < (p += GetAnsiStatus(wp, p)))
5333 *p++ = ' ';
5334 sprintf(p, "(%d,%d)/(%d,%d)",
5335 wp->w_x + 1, wp->w_y + 1, wp->w_width, wp->w_height);
5336 #ifdef COPY_PASTE
5337 sprintf(p += strlen(p), "+%d", wp->w_histheight);
5338 #endif
5339 sprintf(p += strlen(p), " %c%sflow",
5340 (wp->w_flow & FLOW_NOW) ? '+' : '-',
5341 (wp->w_flow & FLOW_AUTOFLAG) ? "" :
5342 ((wp->w_flow & FLOW_AUTO) ? "(+)" : "(-)"));
5343 if (!wp->w_wrap) sprintf(p += strlen(p), " -wrap");
5344 if (wp->w_insert) sprintf(p += strlen(p), " ins");
5345 if (wp->w_origin) sprintf(p += strlen(p), " org");
5346 if (wp->w_keypad) sprintf(p += strlen(p), " app");
5347 if (wp->w_log) sprintf(p += strlen(p), " log");
5348 if (wp->w_monitor != MON_OFF
5349 #ifdef MULTIUSER
5350 && (ACLBYTE(wp->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id))
5351 #endif
5352 )
5353 sprintf(p += strlen(p), " mon");
5354 if (wp->w_mouse) sprintf(p += strlen(p), " mouse");
5355 #ifdef COLOR
5356 if (wp->w_bce) sprintf(p += strlen(p), " bce");
5357 #endif
5358 if (!wp->w_c1) sprintf(p += strlen(p), " -c1");
5359 if (wp->w_norefresh) sprintf(p += strlen(p), " nored");
5360
5361 p += strlen(p);
5362 #ifdef FONT
5363 # ifdef ENCODINGS
5364 if (wp->w_encoding && (display == 0 || D_encoding != wp->w_encoding || EncodingDefFont(wp->w_encoding) <= 0))
5365 {
5366 *p++ = ' ';
5367 strcpy(p, EncodingName(wp->w_encoding));
5368 p += strlen(p);
5369 }
5370 # ifdef UTF8
5371 if (wp->w_encoding != UTF8)
5372 # endif
5373 # endif
5374 if (D_CC0 || (D_CS0 && *D_CS0))
5375 {
5376 if (wp->w_gr == 2)
5377 {
5378 sprintf(p, " G%c", wp->w_Charset + '0');
5379 if (wp->w_FontE >= ' ')
5380 p[3] = wp->w_FontE;
5381 else
5382 {
5383 p[3] = '^';
5384 p[4] = wp->w_FontE ^ 0x40;
5385 p++;
5386 }
5387 p[4] = '[';
5388 p++;
5389 }
5390 else if (wp->w_gr)
5391 sprintf(p++, " G%c%c[", wp->w_Charset + '0', wp->w_CharsetR + '0');
5392 else
5393 sprintf(p, " G%c[", wp->w_Charset + '0');
5394 p += 4;
5395 for (i = 0; i < 4; i++)
5396 {
5397 if (wp->w_charsets[i] == ASCII)
5398 *p++ = 'B';
5399 else if (wp->w_charsets[i] >= ' ')
5400 *p++ = wp->w_charsets[i];
5401 else
5402 {
5403 *p++ = '^';
5404 *p++ = wp->w_charsets[i] ^ 0x40;
5405 }
5406 }
5407 *p++ = ']';
5408 *p = 0;
5409 }
5410 #endif
5411
5412 if (wp->w_type == W_TYPE_PLAIN)
5413 {
5414 /* add info about modem control lines */
5415 *p++ = ' ';
5416 TtyGetModemStatus(wp->w_ptyfd, p);
5417 }
5418 #ifdef BUILTIN_TELNET
5419 else if (wp->w_type == W_TYPE_TELNET)
5420 {
5421 *p++ = ' ';
5422 TelStatus(wp, p, sizeof(buf) - 1 - (p - buf));
5423 }
5424 #endif
5425 Msg(0, "%s %d(%s)", buf, wp->w_number, wp->w_title);
5426 }
5427
5428 static void
5429 ShowDInfo()
5430 {
5431 char buf[512], *p;
5432 if (display == 0)
5433 return;
5434 p = buf;
5435 sprintf(p, "(%d,%d)", D_width, D_height),
5436 p += strlen(p);
5437 #ifdef ENCODINGS
5438 if (D_encoding)
5439 {
5440 *p++ = ' ';
5441 strcpy(p, EncodingName(D_encoding));
5442 p += strlen(p);
5443 }
5444 #endif
5445 if (D_CXT)
5446 {
5447 strcpy(p, " xterm");
5448 p += strlen(p);
5449 }
5450 #ifdef COLOR
5451 if (D_hascolor)
5452 {
5453 strcpy(p, " color");
5454 p += strlen(p);
5455 }
5456 #endif
5457 #ifdef FONT
5458 if (D_CG0)
5459 {
5460 strcpy(p, " iso2022");
5461 p += strlen(p);
5462 }
5463 else if (D_CS0 && *D_CS0)
5464 {
5465 strcpy(p, " altchar");
5466 p += strlen(p);
5467 }
5468 #endif
5469 Msg(0, "%s", buf);
5470 }
5471
5472 static void
5473 AKAfin(buf, len, data)
5474 char *buf;
5475 int len;
5476 char *data; /* dummy */
5477 {
5478 ASSERT(display);
5479 if (len && fore)
5480 ChangeAKA(fore, buf, strlen(buf));
5481 }
5482
5483 static void
5484 InputAKA()
5485 {
5486 char *s, *ss;
5487 int n;
5488 Input("Set window's title to: ", sizeof(fore->w_akabuf) - 1, INP_COOKED, AKAfin, NULL, 0);
5489 s = fore->w_title;
5490 if (!s)
5491 return;
5492 for (; *s; s++)
5493 {
5494 if ((*(unsigned char *)s & 0x7f) < 0x20 || *s == 0x7f)
5495 continue;
5496 ss = s;
5497 n = 1;
5498 LayProcess(&ss, &n);
5499 }
5500 }
5501
5502 static void
5503 Colonfin(buf, len, data)
5504 char *buf;
5505 int len;
5506 char *data; /* dummy */
5507 {
5508 char mbuf[256];
5509
5510 RemoveStatus();
5511 if (buf[len] == '\t')
5512 {
5513 int m, x;
5514 int l = 0, r = RC_LAST;
5515 int showmessage = 0;
5516 char *s = buf;
5517
5518 while (*s && s - buf < len)
5519 if (*s++ == ' ')
5520 return;
5521
5522 /* Showing a message when there's no hardstatus or caption cancels the input */
5523 if (display &&
5524 (captionalways || D_has_hstatus == HSTATUS_LASTLINE || (D_canvas.c_slperp && D_canvas.c_slperp->c_slnext)))
5525 showmessage = 1;
5526
5527 while (l <= r)
5528 {
5529 m = (l + r) / 2;
5530 x = strncmp(buf, comms[m].name, len);
5531 if (x > 0)
5532 l = m + 1;
5533 else if (x < 0)
5534 r = m - 1;
5535 else
5536 {
5537 s = mbuf;
5538 for (l = m - 1; l >= 0 && strncmp(buf, comms[l].name, len) == 0; l--)
5539 ;
5540 for (m = ++l; m <= r && strncmp(buf, comms[m].name, len) == 0 && s - mbuf < sizeof(mbuf); m++)
5541 s += snprintf(s, sizeof(mbuf) - (s - mbuf), " %s", comms[m].name);
5542 if (l < m - 1)
5543 {
5544 if (showmessage)
5545 Msg(0, "Possible commands:%s", mbuf);
5546 }
5547 else
5548 {
5549 s = mbuf;
5550 len = snprintf(mbuf, sizeof(mbuf), "%s \t", comms[l].name + len);
5551 if (len > 0 && len < sizeof(mbuf))
5552 LayProcess(&s, &len);
5553 }
5554 break;
5555 }
5556 }
5557 if (l > r && showmessage)
5558 Msg(0, "No commands matching '%*s'", len, buf);
5559 return;
5560 }
5561
5562 if (!len || buf[len])
5563 return;
5564
5565 len = strlen(buf) + 1;
5566 if (len > (int)sizeof(mbuf))
5567 RcLine(buf, len);
5568 else
5569 {
5570 bcopy(buf, mbuf, len);
5571 RcLine(mbuf, sizeof mbuf);
5572 }
5573 }
5574
5575 static void
5576 SelectFin(buf, len, data)
5577 char *buf;
5578 int len;
5579 char *data; /* dummy */
5580 {
5581 int n;
5582
5583 if (!len || !display)
5584 return;
5585 if (len == 1 && *buf == '-')
5586 {
5587 SetForeWindow((struct win *)0);
5588 Activate(0);
5589 return;
5590 }
5591 if ((n = WindowByNoN(buf)) < 0)
5592 return;
5593 SwitchWindow(n);
5594 }
5595
5596 static void
5597 SelectLayoutFin(buf, len, data)
5598 char *buf;
5599 int len;
5600 char *data; /* dummy */
5601 {
5602 struct layout *lay;
5603
5604 if (!len || !display)
5605 return;
5606 if (len == 1 && *buf == '-')
5607 {
5608 LoadLayout((struct layout *)0, (struct canvas *)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 diff, l;
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