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