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