diff options
Diffstat (limited to '')
| -rw-r--r-- | process.c | 7414 |
1 files changed, 7414 insertions, 0 deletions
diff --git a/process.c b/process.c new file mode 100644 index 0000000..14a7605 --- /dev/null +++ b/process.c @@ -0,0 +1,7414 @@ +/* Copyright (c) 2010 + * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de) + * Sadrul Habib Chowdhury (sadrul@users.sourceforge.net) + * Copyright (c) 2008, 2009 + * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de) + * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de) + * Micah Cowan (micah@cowan.name) + * Sadrul Habib Chowdhury (sadrul@users.sourceforge.net) + * Copyright (c) 1993-2002, 2003, 2005, 2006, 2007 + * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de) + * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de) + * Copyright (c) 1987 Oliver Laumann + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program (see the file COPYING); if not, see + * https://www.gnu.org/licenses/, or contact Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA + * + **************************************************************** + */ + +#include "config.h" + +#include <sys/types.h> +#include <sys/stat.h> +#include <signal.h> +#include <fcntl.h> +#if !defined(sun) && !defined(B43) && !defined(ISC) && !defined(pyr) && !defined(_CX_UX) +# include <time.h> +#endif +#include <sys/time.h> +#ifndef sun +#include <sys/ioctl.h> +#endif + + +/* for solaris 2.1, Unixware (SVR4.2) and possibly others: */ +#ifdef HAVE_STROPTS_H +# include <sys/stropts.h> +#endif + +#include "screen.h" +#include "extern.h" +#include "logfile.h" +#include "layout.h" +#include "viewport.h" +#include "list_generic.h" + +extern struct comm comms[]; +extern char *rc_name; +extern char *RcFileName, *home; +extern char *BellString, *ActivityString, *ShellProg, *ShellArgs[]; +extern char *hstatusstring, *captionstring, *timestring; +extern char *wliststr, *wlisttit; +extern int captionalways; +extern int queryflag; +extern char *hardcopydir, *screenlogfile, *logtstamp_string; +extern int log_flush, logtstamp_on, logtstamp_after; +extern char *VisualBellString; +extern int VBellWait, MsgWait, MsgMinWait, SilenceWait; +extern char SockPath[], *SockName; +extern int TtyMode, auto_detach, use_altscreen; +extern int iflag, maxwin; +extern int focusminwidth, focusminheight; +extern int use_hardstatus, visual_bell; +#ifdef COLOR +extern int attr2color[][4]; +extern int nattr2color; +#endif +extern int hardstatusemu; +extern char *printcmd; +extern int default_startup; +extern int defobuflimit; +extern int defnonblock; +extern int defmousetrack; +extern int ZombieKey_destroy; +extern int ZombieKey_resurrect; +extern int ZombieKey_onerror; +#ifdef AUTO_NUKE +extern int defautonuke; +#endif +extern int separate_sids; +extern struct NewWindow nwin_default, nwin_undef; +#ifdef COPY_PASTE +extern int join_with_cr; +extern int compacthist; +extern int search_ic; +# ifdef FONT +extern int pastefont; +# endif +extern unsigned char mark_key_tab[]; +extern char *BufferFile; +#endif +#ifdef POW_DETACH +extern char *BufferFile, *PowDetachString; +#endif +#ifdef MULTIUSER +extern struct acluser *EffectiveAclUser; /* acl.c */ +#endif +extern struct term term[]; /* terminal capabilities */ +#ifdef MAPKEYS +extern char *kmapdef[]; +extern char *kmapadef[]; +extern char *kmapmdef[]; +#endif +extern struct mchar mchar_so, mchar_null; +extern int renditions[]; +extern int VerboseCreate; +#ifdef UTF8 +extern char *screenencodings; +#endif +#ifdef DW_CHARS +extern int cjkwidth; +#endif + +static int CheckArgNum __P((int, char **)); +static void ClearAction __P((struct action *)); +static void SaveAction __P((struct action *, int, char **, int *)); +static int NextWindow __P((void)); +static int PreviousWindow __P((void)); +static int MoreWindows __P((void)); +static void CollapseWindowlist __P((void)); +static void LogToggle __P((int)); +static void ShowInfo __P((void)); +static void ShowDInfo __P((void)); +static struct win *WindowByName __P((char *)); +static int WindowByNumber __P((char *)); +static int ParseOnOff __P((struct action *, int *)); +static int ParseWinNum __P((struct action *, int *)); +static int ParseBase __P((struct action *, char *, int *, int, char *)); +static int ParseNum1000 __P((struct action *, int *)); +static char **SaveArgs __P((char **)); +static int IsNum __P((char *, int)); +static void Colonfin __P((char *, int, char *)); +static void InputSelect __P((void)); +static void InputSetenv __P((char *)); +static void InputAKA __P((void)); +#ifdef MULTIUSER +static int InputSu __P((struct win *, struct acluser **, char *)); +static void su_fin __P((char *, int, char *)); +#endif +static void AKAfin __P((char *, int, char *)); +#ifdef COPY_PASTE +static void copy_reg_fn __P((char *, int, char *)); +static void ins_reg_fn __P((char *, int, char *)); +#endif +static void process_fn __P((char *, int, char *)); +#ifdef PASSWORD +static void pass1 __P((char *, int, char *)); +static void pass2 __P((char *, int, char *)); +#endif +#ifdef POW_DETACH +static void pow_detach_fn __P((char *, int, char *)); +#endif +static void digraph_fn __P((char *, int, char *)); +static int digraph_find __P((const char *buf)); +static void confirm_fn __P((char *, int, char *)); +static int IsOnDisplay __P((struct win *)); +static void ResizeRegions __P((char *, int)); +static void ResizeFin __P((char *, int, char *)); +static struct action *FindKtab __P((char *, int)); +static void SelectFin __P((char *, int, char *)); +static void SelectLayoutFin __P((char *, int, char *)); +static void ShowWindowsX __P((char *)); + + +extern struct layer *flayer; +extern struct display *display, *displays; +extern struct win *fore, *console_window, *windows; +extern struct acluser *users; +extern struct layout *layouts, *layout_attach, layout_last_marker; +extern struct layout *laytab[]; + +extern char screenterm[], HostName[], version[]; +extern struct NewWindow nwin_undef, nwin_default; +extern struct LayFuncs WinLf, MarkLf; + +extern const int Z0width, Z1width; +extern int real_uid, real_gid; + +#ifdef NETHACK +extern int nethackflag; +#endif + + +extern struct win **wtab; + +#ifdef MULTIUSER +extern char *multi; +extern int maxusercount; +#endif +char NullStr[] = ""; + +struct plop plop_tab[MAX_PLOP_DEFS]; + +#ifndef PTYMODE +# define PTYMODE 0622 +#endif + +int TtyMode = PTYMODE; +int hardcopy_append = 0; +int all_norefresh = 0; +#ifdef ZMODEM +int zmodem_mode = 0; +char *zmodem_sendcmd; +char *zmodem_recvcmd; +static char *zmodes[4] = {"off", "auto", "catch", "pass"}; +#endif + +int idletimo; +struct action idleaction; +#ifdef BLANKER_PRG +char **blankerprg; +#endif + +struct action ktab[256 + KMAP_KEYS]; /* command key translation table */ +struct kclass { + struct kclass *next; + char *name; + struct action ktab[256 + KMAP_KEYS]; +}; +struct kclass *kclasses; + +#ifdef MAPKEYS +struct action umtab[KMAP_KEYS+KMAP_AKEYS]; +struct action dmtab[KMAP_KEYS+KMAP_AKEYS]; +struct action mmtab[KMAP_KEYS+KMAP_AKEYS]; +struct kmap_ext *kmap_exts; +int kmap_extn; +static int maptimeout = 300; +#endif + +#ifndef MAX_DIGRAPH +#define MAX_DIGRAPH 512 +#endif + +struct digraph +{ + unsigned char d[2]; + int value; +}; + +/* digraph table taken from old vim and rfc1345 */ +static struct digraph digraphs[MAX_DIGRAPH + 1] = { + {{' ', ' '}, 160}, /* */ + {{'N', 'S'}, 160}, /* */ + {{'~', '!'}, 161}, /* ¡ */ + {{'!', '!'}, 161}, /* ¡ */ + {{'!', 'I'}, 161}, /* ¡ */ + {{'c', '|'}, 162}, /* ¢ */ + {{'c', 't'}, 162}, /* ¢ */ + {{'$', '$'}, 163}, /* £ */ + {{'P', 'd'}, 163}, /* £ */ + {{'o', 'x'}, 164}, /* ¤ */ + {{'C', 'u'}, 164}, /* ¤ */ + {{'C', 'u'}, 164}, /* ¤ */ + {{'E', 'u'}, 164}, /* ¤ */ + {{'Y', '-'}, 165}, /* ¥ */ + {{'Y', 'e'}, 165}, /* ¥ */ + {{'|', '|'}, 166}, /* ¦ */ + {{'B', 'B'}, 166}, /* ¦ */ + {{'p', 'a'}, 167}, /* § */ + {{'S', 'E'}, 167}, /* § */ + {{'"', '"'}, 168}, /* ¨ */ + {{'\'', ':'}, 168}, /* ¨ */ + {{'c', 'O'}, 169}, /* © */ + {{'C', 'o'}, 169}, /* © */ + {{'a', '-'}, 170}, /* ª */ + {{'<', '<'}, 171}, /* « */ + {{'-', ','}, 172}, /* ¬ */ + {{'N', 'O'}, 172}, /* ¬ */ + {{'-', '-'}, 173}, /* */ + {{'r', 'O'}, 174}, /* ® */ + {{'R', 'g'}, 174}, /* ® */ + {{'-', '='}, 175}, /* ¯ */ + {{'\'', 'm'}, 175}, /* ¯ */ + {{'~', 'o'}, 176}, /* ° */ + {{'D', 'G'}, 176}, /* ° */ + {{'+', '-'}, 177}, /* ± */ + {{'2', '2'}, 178}, /* ² */ + {{'2', 'S'}, 178}, /* ² */ + {{'3', '3'}, 179}, /* ³ */ + {{'3', 'S'}, 179}, /* ³ */ + {{'\'', '\''}, 180}, /* ´ */ + {{'j', 'u'}, 181}, /* µ */ + {{'M', 'y'}, 181}, /* µ */ + {{'p', 'p'}, 182}, /* ¶ */ + {{'P', 'I'}, 182}, /* ¶ */ + {{'~', '.'}, 183}, /* · */ + {{'.', 'M'}, 183}, /* · */ + {{',', ','}, 184}, /* ¸ */ + {{'\'', ','}, 184}, /* ¸ */ + {{'1', '1'}, 185}, /* ¹ */ + {{'1', 'S'}, 185}, /* ¹ */ + {{'o', '-'}, 186}, /* º */ + {{'>', '>'}, 187}, /* » */ + {{'1', '4'}, 188}, /* ¼ */ + {{'1', '2'}, 189}, /* ½ */ + {{'3', '4'}, 190}, /* ¾ */ + {{'~', '?'}, 191}, /* ¿ */ + {{'?', '?'}, 191}, /* ¿ */ + {{'?', 'I'}, 191}, /* ¿ */ + {{'A', '`'}, 192}, /* À */ + {{'A', '!'}, 192}, /* À */ + {{'A', '\''}, 193}, /* Á */ + {{'A', '^'}, 194}, /* Â */ + {{'A', '>'}, 194}, /* Â */ + {{'A', '~'}, 195}, /* Ã */ + {{'A', '?'}, 195}, /* Ã */ + {{'A', '"'}, 196}, /* Ä */ + {{'A', ':'}, 196}, /* Ä */ + {{'A', '@'}, 197}, /* Å */ + {{'A', 'A'}, 197}, /* Å */ + {{'A', 'E'}, 198}, /* Æ */ + {{'C', ','}, 199}, /* Ç */ + {{'E', '`'}, 200}, /* È */ + {{'E', '!'}, 200}, /* È */ + {{'E', '\''}, 201}, /* É */ + {{'E', '^'}, 202}, /* Ê */ + {{'E', '>'}, 202}, /* Ê */ + {{'E', '"'}, 203}, /* Ë */ + {{'E', ':'}, 203}, /* Ë */ + {{'I', '`'}, 204}, /* Ì */ + {{'I', '!'}, 204}, /* Ì */ + {{'I', '\''}, 205}, /* Í */ + {{'I', '^'}, 206}, /* Î */ + {{'I', '>'}, 206}, /* Î */ + {{'I', '"'}, 207}, /* Ï */ + {{'I', ':'}, 207}, /* Ï */ + {{'D', '-'}, 208}, /* Ð */ + {{'N', '~'}, 209}, /* Ñ */ + {{'N', '?'}, 209}, /* Ñ */ + {{'O', '`'}, 210}, /* Ò */ + {{'O', '!'}, 210}, /* Ò */ + {{'O', '\''}, 211}, /* Ó */ + {{'O', '^'}, 212}, /* Ô */ + {{'O', '>'}, 212}, /* Ô */ + {{'O', '~'}, 213}, /* Õ */ + {{'O', '?'}, 213}, /* Õ */ + {{'O', '"'}, 214}, /* Ö */ + {{'O', ':'}, 214}, /* Ö */ + {{'/', '\\'}, 215}, /* × */ + {{'*', 'x'}, 215}, /* × */ + {{'O', '/'}, 216}, /* Ø */ + {{'U', '`'}, 217}, /* Ù */ + {{'U', '!'}, 217}, /* Ù */ + {{'U', '\''}, 218}, /* Ú */ + {{'U', '^'}, 219}, /* Û */ + {{'U', '>'}, 219}, /* Û */ + {{'U', '"'}, 220}, /* Ü */ + {{'U', ':'}, 220}, /* Ü */ + {{'Y', '\''}, 221}, /* Ý */ + {{'I', 'p'}, 222}, /* Þ */ + {{'T', 'H'}, 222}, /* Þ */ + {{'s', 's'}, 223}, /* ß */ + {{'s', '"'}, 223}, /* ß */ + {{'a', '`'}, 224}, /* à */ + {{'a', '!'}, 224}, /* à */ + {{'a', '\''}, 225}, /* á */ + {{'a', '^'}, 226}, /* â */ + {{'a', '>'}, 226}, /* â */ + {{'a', '~'}, 227}, /* ã */ + {{'a', '?'}, 227}, /* ã */ + {{'a', '"'}, 228}, /* ä */ + {{'a', ':'}, 228}, /* ä */ + {{'a', 'a'}, 229}, /* å */ + {{'a', 'e'}, 230}, /* æ */ + {{'c', ','}, 231}, /* ç */ + {{'e', '`'}, 232}, /* è */ + {{'e', '!'}, 232}, /* è */ + {{'e', '\''}, 233}, /* é */ + {{'e', '^'}, 234}, /* ê */ + {{'e', '>'}, 234}, /* ê */ + {{'e', '"'}, 235}, /* ë */ + {{'e', ':'}, 235}, /* ë */ + {{'i', '`'}, 236}, /* ì */ + {{'i', '!'}, 236}, /* ì */ + {{'i', '\''}, 237}, /* í */ + {{'i', '^'}, 238}, /* î */ + {{'i', '>'}, 238}, /* î */ + {{'i', '"'}, 239}, /* ï */ + {{'i', ':'}, 239}, /* ï */ + {{'d', '-'}, 240}, /* ð */ + {{'n', '~'}, 241}, /* ñ */ + {{'n', '?'}, 241}, /* ñ */ + {{'o', '`'}, 242}, /* ò */ + {{'o', '!'}, 242}, /* ò */ + {{'o', '\''}, 243}, /* ó */ + {{'o', '^'}, 244}, /* ô */ + {{'o', '>'}, 244}, /* ô */ + {{'o', '~'}, 245}, /* õ */ + {{'o', '?'}, 245}, /* õ */ + {{'o', '"'}, 246}, /* ö */ + {{'o', ':'}, 246}, /* ö */ + {{':', '-'}, 247}, /* ÷ */ + {{'o', '/'}, 248}, /* ø */ + {{'u', '`'}, 249}, /* ù */ + {{'u', '!'}, 249}, /* ù */ + {{'u', '\''}, 250}, /* ú */ + {{'u', '^'}, 251}, /* û */ + {{'u', '>'}, 251}, /* û */ + {{'u', '"'}, 252}, /* ü */ + {{'u', ':'}, 252}, /* ü */ + {{'y', '\''}, 253}, /* ý */ + {{'i', 'p'}, 254}, /* þ */ + {{'t', 'h'}, 254}, /* þ */ + {{'y', '"'}, 255}, /* ÿ */ + {{'y', ':'}, 255}, /* ÿ */ + {{'"', '['}, 196}, /* Ä */ + {{'"', '\\'}, 214}, /* Ö */ + {{'"', ']'}, 220}, /* Ü */ + {{'"', '{'}, 228}, /* ä */ + {{'"', '|'}, 246}, /* ö */ + {{'"', '}'}, 252}, /* ü */ + {{'"', '~'}, 223} /* ß */ +}; + +#define RESIZE_FLAG_H 1 +#define RESIZE_FLAG_V 2 +#define RESIZE_FLAG_L 4 + +static char *resizeprompts[] = { + "resize # lines: ", + "resize -h # lines: ", + "resize -v # lines: ", + "resize -b # lines: ", + "resize -l # lines: ", + "resize -l -h # lines: ", + "resize -l -v # lines: ", + "resize -l -b # lines: ", +}; + + +static int +parse_input_int(buf, len, val) +const char *buf; +int len; +int *val; +{ + int x = 0, i; + if (len >= 1 && ((*buf == 'U' && buf[1] == '+') || (*buf == '0' && (buf[1] == 'x' || buf[1] == 'X')))) + { + x = 0; + for (i = 2; i < len; i++) + { + if (buf[i] >= '0' && buf[i] <= '9') + x = x * 16 | (buf[i] - '0'); + else if (buf[i] >= 'a' && buf[i] <= 'f') + x = x * 16 | (buf[i] - ('a' - 10)); + else if (buf[i] >= 'A' && buf[i] <= 'F') + x = x * 16 | (buf[i] - ('A' - 10)); + else + return 0; + } + } + else if (buf[0] == '0') + { + x = 0; + for (i = 1; i < len; i++) + { + if (buf[i] < '0' || buf[i] > '7') + return 0; + x = x * 8 | (buf[i] - '0'); + } + } + else + return 0; + *val = x; + return 1; +} + +char *noargs[1]; + +int enter_window_name_mode = 0; + +void +InitKeytab() +{ + register unsigned int i; +#ifdef MAPKEYS + char *argarr[2]; +#endif + + for (i = 0; i < sizeof(ktab)/sizeof(*ktab); i++) + { + ktab[i].nr = RC_ILLEGAL; + ktab[i].args = noargs; + ktab[i].argl = 0; + } +#ifdef MAPKEYS + for (i = 0; i < KMAP_KEYS+KMAP_AKEYS; i++) + { + umtab[i].nr = RC_ILLEGAL; + umtab[i].args = noargs; + umtab[i].argl = 0; + dmtab[i].nr = RC_ILLEGAL; + dmtab[i].args = noargs; + dmtab[i].argl = 0; + mmtab[i].nr = RC_ILLEGAL; + mmtab[i].args = noargs; + mmtab[i].argl = 0; + } + argarr[1] = 0; + for (i = 0; i < NKMAPDEF; i++) + { + if (i + KMAPDEFSTART < T_CAPS) + continue; + if (i + KMAPDEFSTART >= T_CAPS + KMAP_KEYS) + continue; + if (kmapdef[i] == 0) + continue; + argarr[0] = kmapdef[i]; + SaveAction(dmtab + i + (KMAPDEFSTART - T_CAPS), RC_STUFF, argarr, 0); + } + for (i = 0; i < NKMAPADEF; i++) + { + if (i + KMAPADEFSTART < T_CURSOR) + continue; + if (i + KMAPADEFSTART >= T_CURSOR + KMAP_AKEYS) + continue; + if (kmapadef[i] == 0) + continue; + argarr[0] = kmapadef[i]; + SaveAction(dmtab + i + (KMAPADEFSTART - T_CURSOR + KMAP_KEYS), RC_STUFF, argarr, 0); + } + for (i = 0; i < NKMAPMDEF; i++) + { + if (i + KMAPMDEFSTART < T_CAPS) + continue; + if (i + KMAPMDEFSTART >= T_CAPS + KMAP_KEYS) + continue; + if (kmapmdef[i] == 0) + continue; + argarr[0] = kmapmdef[i]; + argarr[1] = 0; + SaveAction(mmtab + i + (KMAPMDEFSTART - T_CAPS), RC_STUFF, argarr, 0); + } +#endif + + ktab['h'].nr = RC_HARDCOPY; +#ifdef BSDJOBS + ktab['z'].nr = ktab[Ctrl('z')].nr = RC_SUSPEND; +#endif + ktab['c'].nr = ktab[Ctrl('c')].nr = RC_SCREEN; + ktab[' '].nr = ktab[Ctrl(' ')].nr = + ktab['n'].nr = ktab[Ctrl('n')].nr = RC_NEXT; + ktab['N'].nr = RC_NUMBER; + ktab[Ctrl('h')].nr = ktab[0177].nr = ktab['p'].nr = ktab[Ctrl('p')].nr = RC_PREV; + ktab['k'].nr = ktab[Ctrl('k')].nr = RC_KILL; + ktab['l'].nr = ktab[Ctrl('l')].nr = RC_REDISPLAY; + ktab['w'].nr = ktab[Ctrl('w')].nr = RC_WINDOWS; + ktab['v'].nr = RC_VERSION; + ktab[Ctrl('v')].nr = RC_DIGRAPH; + ktab['q'].nr = ktab[Ctrl('q')].nr = RC_XON; + ktab['s'].nr = ktab[Ctrl('s')].nr = RC_XOFF; + ktab['t'].nr = ktab[Ctrl('t')].nr = RC_TIME; + ktab['i'].nr = ktab[Ctrl('i')].nr = RC_INFO; + ktab['m'].nr = ktab[Ctrl('m')].nr = RC_LASTMSG; + ktab['A'].nr = RC_TITLE; +#if defined(UTMPOK) && defined(LOGOUTOK) + ktab['L'].nr = RC_LOGIN; +#endif + ktab[','].nr = RC_LICENSE; + ktab['W'].nr = RC_WIDTH; + ktab['.'].nr = RC_DUMPTERMCAP; + ktab[Ctrl('\\')].nr = RC_QUIT; +#ifdef DETACH + ktab['d'].nr = ktab[Ctrl('d')].nr = RC_DETACH; +# ifdef POW_DETACH + ktab['D'].nr = RC_POW_DETACH; +# endif +#endif + ktab['r'].nr = ktab[Ctrl('r')].nr = RC_WRAP; + ktab['f'].nr = ktab[Ctrl('f')].nr = RC_FLOW; + ktab['C'].nr = RC_CLEAR; + ktab['Z'].nr = RC_RESET; + ktab['H'].nr = RC_LOG; + ktab['M'].nr = RC_MONITOR; + ktab['?'].nr = RC_HELP; +#ifdef MULTI + ktab['*'].nr = RC_DISPLAYS; +#endif + { + char *args[2]; + args[0] = "-"; + args[1] = NULL; + SaveAction(ktab + '-', RC_SELECT, args, 0); + } + for (i = 0; i < ((maxwin && maxwin < 10) ? maxwin : 10); i++) + { + char *args[2], arg1[10]; + args[0] = arg1; + args[1] = 0; + sprintf(arg1, "%d", i); + SaveAction(ktab + '0' + i, RC_SELECT, args, 0); + } + ktab['\''].nr = RC_SELECT; /* calling a window by name */ + { + char *args[2]; + args[0] = "-b"; + args[1] = 0; + SaveAction(ktab + '"', RC_WINDOWLIST, args, 0); + } + ktab[Ctrl('G')].nr = RC_VBELL; + ktab[':'].nr = RC_COLON; +#ifdef COPY_PASTE + ktab['['].nr = ktab[Ctrl('[')].nr = RC_COPY; + { + char *args[2]; + args[0] = "."; + args[1] = 0; + SaveAction(ktab + ']', RC_PASTE, args, 0); + SaveAction(ktab + Ctrl(']'), RC_PASTE, args, 0); + } + ktab['{'].nr = RC_HISTORY; + ktab['}'].nr = RC_HISTORY; + ktab['>'].nr = RC_WRITEBUF; + ktab['<'].nr = RC_READBUF; + ktab['='].nr = RC_REMOVEBUF; +#endif +#ifdef POW_DETACH + ktab['D'].nr = RC_POW_DETACH; +#endif +#ifdef LOCK + ktab['x'].nr = ktab[Ctrl('x')].nr = RC_LOCKSCREEN; +#endif + ktab['b'].nr = ktab[Ctrl('b')].nr = RC_BREAK; + ktab['B'].nr = RC_POW_BREAK; + ktab['_'].nr = RC_SILENCE; + ktab['S'].nr = RC_SPLIT; + ktab['Q'].nr = RC_ONLY; + ktab['X'].nr = RC_REMOVE; + ktab['F'].nr = RC_FIT; + ktab['\t'].nr = RC_FOCUS; + { + char *args[2]; + args[0] = "prev"; + args[1] = 0; + SaveAction(ktab + T_BACKTAB - T_CAPS + 256, RC_FOCUS, args, 0); + } + { + char *args[2]; + args[0] = "-v"; + args[1] = 0; + SaveAction(ktab + '|', RC_SPLIT, args, 0); + } + /* These come last; they may want overwrite others: */ + if (DefaultEsc >= 0) + { + ClearAction(&ktab[DefaultEsc]); + ktab[DefaultEsc].nr = RC_OTHER; + } + if (DefaultMetaEsc >= 0) + { + ClearAction(&ktab[DefaultMetaEsc]); + ktab[DefaultMetaEsc].nr = RC_META; + } + + idleaction.nr = RC_BLANKER; + idleaction.args = noargs; + idleaction.argl = 0; +} + +static struct action * +FindKtab(class, create) +char *class; +int create; +{ + struct kclass *kp, **kpp; + int i; + + if (class == 0) + return ktab; + for (kpp = &kclasses; (kp = *kpp) != 0; kpp = &kp->next) + if (!strcmp(kp->name, class)) + break; + if (kp == 0) + { + if (!create) + return 0; + if (strlen(class) > 80) + { + Msg(0, "Command class name too long."); + return 0; + } + kp = malloc(sizeof(*kp)); + if (kp == 0) + { + Msg(0, "%s", strnomem); + return 0; + } + kp->name = SaveStr(class); + for (i = 0; i < (int)(sizeof(kp->ktab)/sizeof(*kp->ktab)); i++) + { + kp->ktab[i].nr = RC_ILLEGAL; + kp->ktab[i].args = noargs; + kp->ktab[i].argl = 0; + kp->ktab[i].quiet = 0; + } + kp->next = 0; + *kpp = kp; + } + return kp->ktab; +} + +static void +ClearAction(act) +struct action *act; +{ + char **p; + + if (act->nr == RC_ILLEGAL) + return; + act->nr = RC_ILLEGAL; + if (act->args == noargs) + return; + for (p = act->args; *p; p++) + free(*p); + free((char *)act->args); + act->args = noargs; + act->argl = 0; +} + +/* + * ProcessInput: process input from display and feed it into + * the layer on canvas D_forecv. + */ + +#ifdef MAPKEYS + +/* + * This ProcessInput just does the keybindings and passes + * everything else on to ProcessInput2. + */ + +void +ProcessInput(ibuf, ilen) +char *ibuf; +int ilen; +{ + int ch, slen; + unsigned char *s, *q; + int i, l; + char *p; + + debug1("ProcessInput: %d bytes\n", ilen); + if (display == 0 || ilen == 0) + return; + if (D_seql) + evdeq(&D_mapev); + slen = ilen; + s = (unsigned char *)ibuf; + while (ilen-- > 0) + { + ch = *s++; + if (D_dontmap || !D_nseqs) + { + D_dontmap = 0; + continue; + } + for (;;) + { + debug3("cmp %c %c[%ld]\n", ch, *D_seqp, (long)(D_seqp - D_kmaps)); + if (*D_seqp != ch) + { + l = D_seqp[D_seqp[-D_seql-1] + 1]; + if (l) + { + D_seqp += l * 2 + 4; + debug1("miss %ld\n", (long)(D_seqp - D_kmaps)); + continue; + } + debug("complete miss\n"); + D_mapdefault = 0; + l = D_seql; + p = (char *)D_seqp - l; + D_seql = 0; + D_seqp = D_kmaps + 3; + if (l == 0) + break; + if ((q = D_seqh) != 0) + { + D_seqh = 0; + i = q[0] << 8 | q[1]; + i &= ~KMAP_NOTIMEOUT; + debug1("Mapping former hit #%d - ", i); + debug2("%d(%s) - ", q[2], q + 3); + if (StuffKey(i)) + ProcessInput2((char *)q + 3, q[2]); + if (display == 0) + return; + l -= q[2]; + p += q[2]; + } + else + D_dontmap = 1; + debug1("flush old %d\n", l); + ProcessInput(p, l); + if (display == 0) + return; + evdeq(&D_mapev); + continue; + } + if (D_seql++ == 0) + { + /* Finish old stuff */ + slen -= ilen + 1; + debug1("finish old %d\n", slen); + if (slen) + ProcessInput2(ibuf, slen); + if (display == 0) + return; + D_seqh = 0; + } + ibuf = (char *)s; + slen = ilen; + D_seqp++; + l = D_seql; + debug2("length am %d, want %d\n", l, D_seqp[-l - 1]); + if (l == D_seqp[-l - 1]) + { + if (D_seqp[l] != l) + { + q = D_seqp + 1 + l; + if (D_kmaps + D_nseqs > q && q[2] > l && !bcmp(D_seqp - l, q + 3, l)) + { + debug1("have another mapping (%s), delay execution\n", q + 3); + D_seqh = D_seqp - 3 - l; + D_seqp = q + 3 + l; + break; + } + } + i = D_seqp[-l - 3] << 8 | D_seqp[-l - 2]; + i &= ~KMAP_NOTIMEOUT; + debug1("Mapping #%d - ", i); + p = (char *)D_seqp - l; + debug2("%d(%s) - ", l, p); + D_seql = 0; + D_seqp = D_kmaps + 3; + D_seqh = 0; + if (StuffKey(i)) + ProcessInput2(p, l); + if (display == 0) + return; + } + break; + } + } + if (D_seql) + { + debug("am in sequence -> check for timeout\n"); + l = D_seql; + for (s = D_seqp; ; s += i * 2 + 4) + { + if (s[-l-3] & KMAP_NOTIMEOUT >> 8) + break; + if ((i = s[s[-l-1] + 1]) == 0) + { + SetTimeout(&D_mapev, maptimeout); + evenq(&D_mapev); + break; + } + } + } + ProcessInput2(ibuf, slen); +} + +#else +# define ProcessInput2 ProcessInput +#endif + + +/* + * Here only the screen escape commands are handled. + */ + +void +ProcessInput2(ibuf, ilen) +char *ibuf; +int ilen; +{ + char *s; + int ch, slen; + struct action *ktabp; + + debug1("ProcessInput2: %d bytes\n", ilen); + while (ilen && display) + { + debug1(" - ilen now %d bytes\n", ilen); + flayer = D_forecv->c_layer; + fore = D_fore; + slen = ilen; + s = ibuf; + if (!D_ESCseen) + { + while (ilen > 0) + { + if ((unsigned char)*s++ == D_user->u_Esc) + break; + ilen--; + } + slen -= ilen; + if (slen) + DoProcess(fore, &ibuf, &slen, 0); + if (--ilen == 0) + { + D_ESCseen = ktab; + WindowChanged(fore, 'E'); + } + } + if (ilen <= 0) + return; + ktabp = D_ESCseen ? D_ESCseen : ktab; + if (D_ESCseen) + { + D_ESCseen = 0; + WindowChanged(fore, 'E'); + } + ch = (unsigned char)*s; + + /* + * As users have different esc characters, but a common ktab[], + * we fold back the users esc and meta-esc key to the Default keys + * that can be looked up in the ktab[]. grmbl. jw. + * XXX: make ktab[] a per user thing. + */ + if (ch == D_user->u_Esc) + ch = DefaultEsc; + else if (ch == D_user->u_MetaEsc) + ch = DefaultMetaEsc; + + if (ch >= 0) + DoAction(&ktabp[ch], ch); + ibuf = (char *)(s + 1); + ilen--; + } +} + +void +DoProcess(p, bufp, lenp, pa) +struct win *p; +char **bufp; +int *lenp; +struct paster *pa; +{ + int oldlen; + struct display *d = display; + +#ifdef COPY_PASTE + /* XXX -> PasteStart */ + if (pa && *lenp > 1 && p && p->w_slowpaste) + { + /* schedule slowpaste event */ + SetTimeout(&p->w_paster.pa_slowev, p->w_slowpaste); + evenq(&p->w_paster.pa_slowev); + return; + } +#endif + while (flayer && *lenp) + { +#ifdef COPY_PASTE + if (!pa && p && p->w_paster.pa_pastelen && flayer == p->w_paster.pa_pastelayer) + { + debug("layer is busy - beep!\n"); + WBell(p, visual_bell); + *bufp += *lenp; + *lenp = 0; + display = d; + return; + } +#endif + oldlen = *lenp; + LayProcess(bufp, lenp); +#ifdef COPY_PASTE + if (pa && !pa->pa_pastelayer) + break; /* flush rest of paste */ +#endif + if (*lenp == oldlen) + { + if (pa) + { + display = d; + return; + } + /* We're full, let's beep */ + debug("layer is full - beep!\n"); + WBell(p, visual_bell); + break; + } + } + *bufp += *lenp; + *lenp = 0; + display = d; +#ifdef COPY_PASTE + if (pa && pa->pa_pastelen == 0) + FreePaster(pa); +#endif +} + +int +FindCommnr(str) +const char *str; +{ + int x, m, l = 0, r = RC_LAST; + while (l <= r) + { + m = (l + r) / 2; + x = strcmp(str, comms[m].name); + if (x > 0) + l = m + 1; + else if (x < 0) + r = m - 1; + else + return m; + } + return RC_ILLEGAL; +} + +static int +CheckArgNum(nr, args) +int nr; +char **args; +{ + int i, n; + static char *argss[] = {"no", "one", "two", "three", "four", "OOPS"}; + static char *orformat[] = + { + "%s: %s: %s argument%s required", + "%s: %s: %s or %s argument%s required", + "%s: %s: %s, %s or %s argument%s required", + "%s: %s: %s, %s, %s or %s argument%s required" + }; + + n = comms[nr].flags & ARGS_MASK; + for (i = 0; args[i]; i++) + ; + if (comms[nr].flags & ARGS_ORMORE) + { + if (i < n) + { + Msg(0, "%s: %s: at least %s argument%s required", + rc_name, comms[nr].name, argss[n], n != 1 ? "s" : ""); + return -1; + } + } + else if ((comms[nr].flags & ARGS_PLUS1) && + (comms[nr].flags & ARGS_PLUS2) && + (comms[nr].flags & ARGS_PLUS3)) + { + if (i != n && i != n + 1 && i != n + 2 && i != n + 3) + { + Msg(0, orformat[3], rc_name, comms[nr].name, argss[n], + argss[n + 1], argss[n + 2], argss[n + 3], ""); + return -1; + } + } + else if ((comms[nr].flags & ARGS_PLUS1) && + (comms[nr].flags & ARGS_PLUS2)) + { + if (i != n && i != n + 1 && i != n + 2) + { + Msg(0, orformat[2], rc_name, comms[nr].name, argss[n], + argss[n + 1], argss[n + 2], ""); + return -1; + } + } + else if ((comms[nr].flags & ARGS_PLUS1) && + (comms[nr].flags & ARGS_PLUS3)) + { + if (i != n && i != n + 1 && i != n + 3) + { + Msg(0, orformat[2], rc_name, comms[nr].name, argss[n], + argss[n + 1], argss[n + 3], ""); + return -1; + } + } + else if ((comms[nr].flags & ARGS_PLUS2) && + (comms[nr].flags & ARGS_PLUS3)) + { + if (i != n && i != n + 2 && i != n + 3) + { + Msg(0, orformat[2], rc_name, comms[nr].name, argss[n], + argss[n + 2], argss[n + 3], ""); + return -1; + } + } + else if (comms[nr].flags & ARGS_PLUS1) + { + if (i != n && i != n + 1) + { + Msg(0, orformat[1], rc_name, comms[nr].name, argss[n], + argss[n + 1], n != 0 ? "s" : ""); + return -1; + } + } + else if (comms[nr].flags & ARGS_PLUS2) + { + if (i != n && i != n + 2) + { + Msg(0, orformat[1], rc_name, comms[nr].name, argss[n], + argss[n + 2], "s"); + return -1; + } + } + else if (comms[nr].flags & ARGS_PLUS3) + { + if (i != n && i != n + 3) + { + Msg(0, orformat[1], rc_name, comms[nr].name, argss[n], + argss[n + 3], ""); + return -1; + } + } + else if (i != n) + { + Msg(0, orformat[0], rc_name, comms[nr].name, argss[n], n != 1 ? "s" : ""); + return -1; + } + return i; +} + +static void +StuffFin(buf, len, data) +char *buf; +int len; +char *data; +{ + if (!flayer) + return; + while(len) + LayProcess(&buf, &len); +} + +/* If the command is not 'quieted', then use Msg to output the message. If it's a remote + * query, then Msg takes care of also outputting the message to the querying client. + * + * If we want the command to be quiet, and it's a remote query, then use QueryMsg so that + * the response does go back to the querying client. + * + * If the command is quieted, and it's not a remote query, then just don't print the message. + */ +#define OutputMsg (!act->quiet ? Msg : queryflag >= 0 ? QueryMsg : Dummy) + +/*ARGSUSED*/ +void +DoAction(act, key) +struct action *act; +int key; +{ + int nr = act->nr; + char **args = act->args; + int *argl = act->argl; + struct win *p; + int argc, i, n, msgok; + char *s; + char ch; + struct display *odisplay = display; + struct acluser *user; + + user = display ? D_user : users; + if (nr == RC_ILLEGAL) + { + debug1("key '%c': No action\n", key); + return; + } + n = comms[nr].flags; + /* Commands will have a CAN_QUERY flag, depending on whether they have + * something to return on a query. For example, 'windows' can return a result, + * but 'other' cannot. + * If some command causes an error, then it should reset queryflag to -1, so that + * the process requesting the query can be notified that an error happened. + */ + if (!(n & CAN_QUERY) && queryflag >= 0) + { + /* Query flag is set, but this command cannot be queried. */ + OutputMsg(0, "%s command cannot be queried.", comms[nr].name); + queryflag = -1; + return; + } + if ((n & NEED_DISPLAY) && display == 0) + { + OutputMsg(0, "%s: %s: display required", rc_name, comms[nr].name); + queryflag = -1; + return; + } + if ((n & NEED_FORE) && fore == 0) + { + OutputMsg(0, "%s: %s: window required", rc_name, comms[nr].name); + queryflag = -1; + return; + } + if ((n & NEED_LAYER) && flayer == 0) + { + OutputMsg(0, "%s: %s: display or window required", rc_name, comms[nr].name); + queryflag = -1; + return; + } + if ((argc = CheckArgNum(nr, args)) < 0) + return; +#ifdef MULTIUSER + if (display) + { + if (AclCheckPermCmd(D_user, ACL_EXEC, &comms[nr])) + { + OutputMsg(0, "%s: %s: permission denied (user %s)", + rc_name, comms[nr].name, (EffectiveAclUser ? EffectiveAclUser : D_user)->u_name); + queryflag = -1; + return; + } + } +#endif /* MULTIUSER */ + + msgok = display && !*rc_name; + switch(nr) + { + case RC_SELECT: + if (!*args) + InputSelect(); + else if (args[0][0] == '-' && !args[0][1]) + { + SetForeWindow((struct win *)0); + Activate(0); + } + else if (args[0][0] == '.' && !args[0][1]) + { + if (!fore) + { + OutputMsg(0, "select . needs a window"); + queryflag = -1; + } + else + { + SetForeWindow(fore); + Activate(0); + } + } + else if (ParseWinNum(act, &n) == 0) + SwitchWindow(n); + else if (queryflag >= 0) + queryflag = -1; /* ParseWinNum already prints out an appropriate error message. */ + break; +#ifdef AUTO_NUKE + case RC_DEFAUTONUKE: + if (ParseOnOff(act, &defautonuke) == 0 && msgok) + OutputMsg(0, "Default autonuke turned %s", defautonuke ? "on" : "off"); + if (display && *rc_name) + D_auto_nuke = defautonuke; + break; + case RC_AUTONUKE: + if (ParseOnOff(act, &D_auto_nuke) == 0 && msgok) + OutputMsg(0, "Autonuke turned %s", D_auto_nuke ? "on" : "off"); + break; +#endif + case RC_DEFOBUFLIMIT: + if (ParseNum(act, &defobuflimit) == 0 && msgok) + OutputMsg(0, "Default limit set to %d", defobuflimit); + if (display && *rc_name) + { + D_obufmax = defobuflimit; + D_obuflenmax = D_obuflen - D_obufmax; + } + break; + case RC_OBUFLIMIT: + if (*args == 0) + OutputMsg(0, "Limit is %d, current buffer size is %d", D_obufmax, D_obuflen); + else if (ParseNum(act, &D_obufmax) == 0 && msgok) + OutputMsg(0, "Limit set to %d", D_obufmax); + D_obuflenmax = D_obuflen - D_obufmax; + break; + case RC_DUMPTERMCAP: + WriteFile(user, (char *)0, DUMP_TERMCAP); + break; + case RC_HARDCOPY: + { + int mode = DUMP_HARDCOPY; + char *file = NULL; + + if (args[0]) + { + if (!strcmp(*args, "-h")) + { + mode = DUMP_SCROLLBACK; + file = args[1]; + } + else if (!strcmp(*args, "--") && args[1]) + file = args[1]; + else + file = args[0]; + } + + if (args[0] && file == args[0] && args[1]) + { + OutputMsg(0, "%s: hardcopy: too many arguments", rc_name); + break; + } + WriteFile(user, file, mode); + } + break; + case RC_DEFLOG: + (void)ParseOnOff(act, &nwin_default.Lflag); + break; + case RC_LOG: + n = fore->w_log ? 1 : 0; + ParseSwitch(act, &n); + LogToggle(n); + break; +#ifdef BSDJOBS + case RC_SUSPEND: + Detach(D_STOP); + break; +#endif + case RC_NEXT: + if (MoreWindows()) + SwitchWindow(NextWindow()); + break; + case RC_PREV: + if (MoreWindows()) + SwitchWindow(PreviousWindow()); + break; + case RC_KILL: + { + char *name; + + if (key >= 0) + { +#ifdef PSEUDOS + Input(fore->w_pwin ? "Really kill this filter [y/n]" : "Really kill this window [y/n]", 1, INP_RAW, confirm_fn, NULL, RC_KILL); +#else + Input("Really kill this window [y/n]", 1, INP_RAW, confirm_fn, NULL, RC_KILL); +#endif + break; + } + n = fore->w_number; +#ifdef PSEUDOS + if (fore->w_pwin) + { + FreePseudowin(fore); + OutputMsg(0, "Filter removed."); + break; + } +#endif + name = SaveStr(fore->w_title); + KillWindow(fore); + OutputMsg(0, "Window %d (%s) killed.", n, name); + if (name) + free(name); + break; + } + case RC_QUIT: + if (key >= 0) + { + Input("Really quit and kill all your windows [y/n]", 1, INP_RAW, confirm_fn, NULL, RC_QUIT); + break; + } + Finit(0); + /* NOTREACHED */ +#ifdef DETACH + case RC_DETACH: + if (*args && !strcmp(*args, "-h")) + Hangup(); + else + Detach(D_DETACH); + break; +# ifdef POW_DETACH + case RC_POW_DETACH: + if (key >= 0) + { + static char buf[2]; + + buf[0] = key; + Input(buf, 1, INP_RAW, pow_detach_fn, NULL, 0); + } + else + Detach(D_POWER); /* detach and kill Attacher's parent */ + break; +# endif +#endif + case RC_DEBUG: +#ifdef DEBUG + if (!*args) + { + if (dfp) + OutputMsg(0, "debugging info is written to %s/", DEBUGDIR); + else + OutputMsg(0, "debugging is currently off. Use 'debug on' to enable."); + break; + } + if (dfp) + { + debug("debug: closing debug file.\n"); + fflush(dfp); + fclose(dfp); + dfp = NULL; + } + if (strcmp("off", *args)) + opendebug(0, 1); +# ifdef SIG_NODEBUG + else if (display) + kill(D_userpid, SIG_NODEBUG); /* a one shot item, but hey... */ +# endif /* SIG_NODEBUG */ +#else + if (*args == 0 || strcmp("off", *args)) + OutputMsg(0, "Sorry, screen was compiled without -DDEBUG option."); +#endif + break; +#ifdef ZMODEM + case RC_ZMODEM: + if (*args && !strcmp(*args, "sendcmd")) + { + if (args[1]) + { + free(zmodem_sendcmd); + zmodem_sendcmd = SaveStr(args[1]); + } + if (msgok) + OutputMsg(0, "zmodem sendcmd: %s", zmodem_sendcmd); + break; + } + if (*args && !strcmp(*args, "recvcmd")) + { + if (args[1]) + { + free(zmodem_recvcmd); + zmodem_recvcmd = SaveStr(args[1]); + } + if (msgok) + OutputMsg(0, "zmodem recvcmd: %s", zmodem_recvcmd); + break; + } + if (*args) + { + for (i = 0; i < 4; i++) + if (!strcmp(zmodes[i], *args)) + break; + if (i == 4 && !strcmp(*args, "on")) + i = 1; + if (i == 4) + { + OutputMsg(0, "usage: zmodem off|auto|catch|pass"); + break; + } + zmodem_mode = i; + } + if (msgok) + OutputMsg(0, "zmodem mode is %s", zmodes[zmodem_mode]); + break; +#endif + case RC_UNBINDALL: + { + register unsigned int i; + + for (i = 0; i < sizeof(ktab)/sizeof(*ktab); i++) + ClearAction(&ktab[i]); + OutputMsg(0, "Unbound all keys." ); + break; + } + case RC_ZOMBIE: + { + if (!(s = *args)) + { + ZombieKey_destroy = 0; + break; + } + if (*argl == 0 || *argl > 2) + { + OutputMsg(0, "%s:zombie: one or two characters expected.", rc_name); + break; + } + if (args[1]) + { + if (!strcmp(args[1], "onerror")) + { + ZombieKey_onerror = 1; + } else { + OutputMsg(0, "usage: zombie [keys [onerror]]"); + break; + } + } else + ZombieKey_onerror = 0; + ZombieKey_destroy = args[0][0]; + ZombieKey_resurrect = *argl == 2 ? args[0][1] : 0; + } + break; + case RC_WALL: +#ifdef MULTIUSER + s = D_user->u_name; +#else + s = D_usertty; +#endif + { + struct display *olddisplay = display; + display = 0; /* no display will cause a broadcast */ + OutputMsg(0, "%s: %s", s, *args); + display = olddisplay; + } + break; + case RC_AT: + /* where this AT command comes from: */ + if (!user) + break; +#ifdef MULTIUSER + s = SaveStr(user->u_name); + /* DO NOT RETURN FROM HERE WITHOUT RESETTING THIS: */ + EffectiveAclUser = user; +#else + s = SaveStr(display ? D_usertty : user->u_name); +#endif + n = strlen(args[0]); + if (n) n--; + /* + * the windows/displays loops are quite dangerous here, take extra + * care not to trigger landmines. Things may appear/disappear while + * we are walking along. + */ + switch (args[0][n]) + { + case '*': /* user */ + { + struct display *nd; + struct acluser *u; + + if (!n) + u = user; + else + { + for (u = users; u; u = u->u_next) + { + debug3("strncmp('%s', '%s', %d)\n", *args, u->u_name, n); + if (!strncmp(*args, u->u_name, n)) + break; + } + if (!u) + { + args[0][n] = '\0'; + OutputMsg(0, "Did not find any user matching '%s'", args[0]); + break; + } + } + debug1("at all displays of user %s\n", u->u_name); + for (display = displays; display; display = nd) + { + nd = display->d_next; + if (D_forecv == 0) + continue; + flayer = D_forecv->c_layer; + fore = D_fore; + if (D_user != u) + continue; + debug1("AT display %s\n", D_usertty); + DoCommand(args + 1, argl + 1); + if (display) + OutputMsg(0, "command from %s: %s %s", + s, args[1], args[2] ? args[2] : ""); + display = NULL; + flayer = 0; + fore = NULL; + } + break; + } + case '%': /* display */ + { + struct display *nd; + + debug1("at display matching '%s'\n", args[0]); + for (display = displays; display; display = nd) + { + nd = display->d_next; + if (D_forecv == 0) + continue; + fore = D_fore; + flayer = D_forecv->c_layer; + if (strncmp(args[0], D_usertty, n) && + (strncmp("/dev/", D_usertty, 5) || + strncmp(args[0], D_usertty + 5, n)) && + (strncmp("/dev/tty", D_usertty, 8) || + strncmp(args[0], D_usertty + 8, n))) + continue; + debug1("AT display %s\n", D_usertty); + DoCommand(args + 1, argl + 1); + if (display) + OutputMsg(0, "command from %s: %s %s", + s, args[1], args[2] ? args[2] : ""); + display = NULL; + fore = NULL; + flayer = 0; + } + break; + } + case '#': /* window */ + n--; + /* FALLTHROUGH */ + default: + { + struct win *nw; + int ch; + + n++; + ch = args[0][n]; + args[0][n] = '\0'; + if (!*args[0] || (i = WindowByNumber(args[0])) < 0) + { + args[0][n] = ch; /* must restore string in case of bind */ + /* try looping over titles */ + for (fore = windows; fore; fore = nw) + { + nw = fore->w_next; + if (strncmp(args[0], fore->w_title, n)) + continue; + debug2("AT window %d(%s)\n", fore->w_number, fore->w_title); + /* + * consider this a bug or a feature: + * while looping through windows, we have fore AND + * display context. This will confuse users who try to + * set up loops inside of loops, but often allows to do + * what you mean, even when you adress your context wrong. + */ + i = 0; + /* XXX: other displays? */ + if (fore->w_layer.l_cvlist) + display = fore->w_layer.l_cvlist->c_display; + flayer = fore->w_savelayer ? fore->w_savelayer : &fore->w_layer; + DoCommand(args + 1, argl + 1); /* may destroy our display */ + if (fore && fore->w_layer.l_cvlist) + { + display = fore->w_layer.l_cvlist->c_display; + OutputMsg(0, "command from %s: %s %s", + s, args[1], args[2] ? args[2] : ""); + } + } + display = NULL; + fore = NULL; + if (i < 0) + OutputMsg(0, "%s: at '%s': no such window.\n", rc_name, args[0]); + break; + } + else if (i < maxwin && (fore = wtab[i])) + { + args[0][n] = ch; /* must restore string in case of bind */ + debug2("AT window %d (%s)\n", fore->w_number, fore->w_title); + if (fore->w_layer.l_cvlist) + display = fore->w_layer.l_cvlist->c_display; + flayer = fore->w_savelayer ? fore->w_savelayer : &fore->w_layer; + DoCommand(args + 1, argl + 1); + if (fore && fore->w_layer.l_cvlist) + { + display = fore->w_layer.l_cvlist->c_display; + OutputMsg(0, "command from %s: %s %s", + s, args[1], args[2] ? args[2] : ""); + } + display = NULL; + fore = NULL; + } + else + OutputMsg(0, "%s: at [identifier][%%|*|#] command [args]", rc_name); + break; + } + } + free(s); +#ifdef MULTIUSER + EffectiveAclUser = NULL; +#endif + break; + +#ifdef COPY_PASTE + case RC_READREG: +#ifdef ENCODINGS + i = fore ? fore->w_encoding : display ? display->d_encoding : 0; + if (args[0] && args[1] && !strcmp(args[0], "-e")) + { + i = FindEncoding(args[1]); + if (i == -1) + { + OutputMsg(0, "%s: readreg: unknown encoding", rc_name); + break; + } + args += 2; + } +#endif + /* + * Without arguments we prompt for a destination register. + * It will receive the copybuffer contents. + * This is not done by RC_PASTE, as we prompt for source + * (not dest) there. + */ + if ((s = *args) == NULL) + { + Input("Copy to register:", 1, INP_RAW, copy_reg_fn, NULL, 0); + break; + } + if (*argl != 1) + { + OutputMsg(0, "%s: copyreg: character, ^x, or (octal) \\032 expected.", rc_name); + break; + } + ch = args[0][0]; + /* + * With two arguments we *really* read register contents from file + */ + if (args[1]) + { + if (args[2]) + { + OutputMsg(0, "%s: readreg: too many arguments", rc_name); + break; + } + if ((s = ReadFile(args[1], &n))) + { + struct plop *pp = plop_tab + (int)(unsigned char)ch; + + if (pp->buf) + free(pp->buf); + pp->buf = s; + pp->len = n; +#ifdef ENCODINGS + pp->enc = i; +#endif + } + } + else + /* + * with one argument we copy the copybuffer into a specified register + * This could be done with RC_PASTE too, but is here to be consistent + * with the zero argument call. + */ + copy_reg_fn(&ch, 0, NULL); + break; +#endif + case RC_REGISTER: +#ifdef ENCODINGS + i = fore ? fore->w_encoding : display ? display->d_encoding : 0; + if (args[0] && args[1] && !strcmp(args[0], "-e")) + { + i = FindEncoding(args[1]); + if (i == -1) + { + OutputMsg(0, "%s: register: unknown encoding", rc_name); + break; + } + args += 2; + argc -= 2; + } +#endif + if (argc != 2) + { + OutputMsg(0, "%s: register: illegal number of arguments.", rc_name); + break; + } + if (*argl != 1) + { + OutputMsg(0, "%s: register: character, ^x, or (octal) \\032 expected.", rc_name); + break; + } + ch = args[0][0]; +#ifdef COPY_PASTE + if (ch == '.') + { + if (user->u_plop.buf != NULL) + UserFreeCopyBuffer(user); + if (args[1] && args[1][0]) + { + user->u_plop.buf = SaveStrn(args[1], argl[1]); + user->u_plop.len = argl[1]; +#ifdef ENCODINGS + user->u_plop.enc = i; +#endif + } + } + else +#endif + { + struct plop *plp = plop_tab + (int)(unsigned char)ch; + + if (plp->buf) + free(plp->buf); + plp->buf = SaveStrn(args[1], argl[1]); + plp->len = argl[1]; +#ifdef ENCODINGS + plp->enc = i; +#endif + } + break; + case RC_PROCESS: + if ((s = *args) == NULL) + { + Input("Process register:", 1, INP_RAW, process_fn, NULL, 0); + break; + } + if (*argl != 1) + { + OutputMsg(0, "%s: process: character, ^x, or (octal) \\032 expected.", rc_name); + break; + } + ch = args[0][0]; + process_fn(&ch, 0, NULL); + break; + case RC_STUFF: + s = *args; + if (!args[0]) + { + Input("Stuff:", 100, INP_COOKED, StuffFin, NULL, 0); + break; + } + n = *argl; + if (args[1]) + { + if (strcmp(s, "-k")) + { + OutputMsg(0, "%s: stuff: invalid option %s", rc_name, s); + break; + } + s = args[1]; + for (i = T_CAPS; i < T_OCAPS; i++) + if (strcmp(term[i].tcname, s) == 0) + break; + if (i == T_OCAPS) + { + OutputMsg(0, "%s: stuff: unknown key '%s'", rc_name, s); + break; + } +#ifdef MAPKEYS + if (StuffKey(i - T_CAPS) == 0) + break; +#endif + s = display ? D_tcs[i].str : 0; + if (s == 0) + break; + n = strlen(s); + } + while(n) + LayProcess(&s, &n); + break; + case RC_REDISPLAY: + Activate(-1); + break; + case RC_WINDOWS: + if (args[0]) { + ShowWindowsX(args[0]); + break; + } + ShowWindows(-1); + break; + case RC_VERSION: + OutputMsg(0, "screen %s", version); + break; + case RC_TIME: + if (*args) + { + timestring = SaveStr(*args); + break; + } + OutputMsg(0, "%s", MakeWinMsg(timestring, fore, '%')); + break; + case RC_INFO: + ShowInfo(); + break; + case RC_DINFO: + ShowDInfo(); + break; + case RC_COMMAND: + { + struct action *ktabp = ktab; + if (argc == 2 && !strcmp(*args, "-c")) + { + if ((ktabp = FindKtab(args[1], 0)) == 0) + { + OutputMsg(0, "Unknown command class '%s'", args[1]); + break; + } + } + if (D_ESCseen != ktab || ktabp != ktab) + { + if (D_ESCseen != ktabp) + { + D_ESCseen = ktabp; + WindowChanged(fore, 'E'); + } + break; + } + if (D_ESCseen) + { + D_ESCseen = 0; + WindowChanged(fore, 'E'); + } + } + /* FALLTHROUGH */ + case RC_OTHER: + if (MoreWindows()) + SwitchWindow(display && D_other ? D_other->w_number : NextWindow()); + break; + case RC_META: + if (user->u_Esc == -1) + break; + ch = user->u_Esc; + s = &ch; + n = 1; + LayProcess(&s, &n); + break; + case RC_XON: + ch = Ctrl('q'); + s = &ch; + n = 1; + LayProcess(&s, &n); + break; + case RC_XOFF: + ch = Ctrl('s'); + s = &ch; + n = 1; + LayProcess(&s, &n); + break; + case RC_DEFBREAKTYPE: + case RC_BREAKTYPE: + { + static char *types[] = { "TIOCSBRK", "TCSBRK", "tcsendbreak", NULL }; + extern int breaktype; + + if (*args) + { + if (ParseNum(act, &n)) + for (n = 0; n < (int)(sizeof(types)/sizeof(*types)); n++) + { + for (i = 0; i < 4; i++) + { + ch = args[0][i]; + if (ch >= 'a' && ch <= 'z') + ch -= 'a' - 'A'; + if (ch != types[n][i] && (ch + ('a' - 'A')) != types[n][i]) + break; + } + if (i == 4) + break; + } + if (n < 0 || n >= (int)(sizeof(types)/sizeof(*types))) + OutputMsg(0, "%s invalid, chose one of %s, %s or %s", *args, types[0], types[1], types[2]); + else + { + breaktype = n; + OutputMsg(0, "breaktype set to (%d) %s", n, types[n]); + } + } + else + OutputMsg(0, "breaktype is (%d) %s", breaktype, types[breaktype]); + } + break; + case RC_POW_BREAK: + case RC_BREAK: + n = 0; + if (*args && ParseNum(act, &n)) + break; + SendBreak(fore, n, nr == RC_POW_BREAK); + break; +#ifdef LOCK + case RC_LOCKSCREEN: + Detach(D_LOCK); + break; +#endif + case RC_WIDTH: + case RC_HEIGHT: + { + int w, h; + int what = 0; + + i = 1; + if (*args && !strcmp(*args, "-w")) + what = 1; + else if (*args && !strcmp(*args, "-d")) + what = 2; + if (what) + args++; + if (what == 0 && flayer && !display) + what = 1; + if (what == 1) + { + if (!flayer) + { + OutputMsg(0, "%s: %s: window required", rc_name, comms[nr].name); + break; + } + w = flayer->l_width; + h = flayer->l_height; + } + else + { + if (!display) + { + OutputMsg(0, "%s: %s: display required", rc_name, comms[nr].name); + break; + } + w = D_width; + h = D_height; + } + if (*args && args[0][0] == '-') + { + OutputMsg(0, "%s: %s: unknown option %s", rc_name, comms[nr].name, *args); + break; + } + if (nr == RC_HEIGHT) + { + if (!*args) + { +#define H0height 42 +#define H1height 24 + if (h == H0height) + h = H1height; + else if (h == H1height) + h = H0height; + else if (h > (H0height + H1height) / 2) + h = H0height; + else + h = H1height; + } + else + { + h = atoi(*args); + if (args[1]) + w = atoi(args[1]); + } + } + else + { + if (!*args) + { + if (w == Z0width) + w = Z1width; + else if (w == Z1width) + w = Z0width; + else if (w > (Z0width + Z1width) / 2) + w = Z0width; + else + w = Z1width; + } + else + { + w = atoi(*args); + if (args[1]) + h = atoi(args[1]); + } + } + if (*args && args[1] && args[2]) + { + OutputMsg(0, "%s: %s: too many arguments", rc_name, comms[nr].name); + break; + } + if (w <= 0) + { + OutputMsg(0, "Illegal width"); + break; + } + if (h <= 0) + { + OutputMsg(0, "Illegal height"); + break; + } + if (what == 1) + { + if (flayer->l_width == w && flayer->l_height == h) + break; + ResizeLayer(flayer, w, h, (struct display *)0); + break; + } + if (D_width == w && D_height == h) + break; + if (what == 2) + { + ChangeScreenSize(w, h, 1); + } + else + { + if (ResizeDisplay(w, h) == 0) + { + Activate(D_fore ? D_fore->w_norefresh : 0); + /* autofit */ + ResizeLayer(D_forecv->c_layer, D_forecv->c_xe - D_forecv->c_xs + 1, D_forecv->c_ye - D_forecv->c_ys + 1, 0); + break; + } + if (h == D_height) + OutputMsg(0, "Your termcap does not specify how to change the terminal's width to %d.", w); + else if (w == D_width) + OutputMsg(0, "Your termcap does not specify how to change the terminal's height to %d.", h); + else + OutputMsg(0, "Your termcap does not specify how to change the terminal's resolution to %dx%d.", w, h); + } + } + break; + case RC_DEFDYNAMICTITLE: + (void)ParseOnOff(act, &nwin_default.dynamicaka); + break; + case RC_DYNAMICTITLE: + (void)ParseOnOff(act, &fore->w_dynamicaka); + break; + case RC_TITLE: + if (queryflag >= 0) + { + if (fore) + OutputMsg(0, "%s", fore->w_title); + else + queryflag = -1; + break; + } + if (*args == 0) + InputAKA(); + else + ChangeAKA(fore, *args, strlen(*args)); + break; + case RC_COLON: + Input(":", MAXSTR, INP_EVERY, Colonfin, NULL, 0); + if (*args && **args) + { + s = *args; + n = strlen(s); + LayProcess(&s, &n); + } + break; + case RC_LASTMSG: + if (D_status_lastmsg) + OutputMsg(0, "%s", D_status_lastmsg); + break; + case RC_SCREEN: + DoScreen("key", args); + break; + case RC_WRAP: + if (ParseSwitch(act, &fore->w_wrap) == 0 && msgok) + OutputMsg(0, "%cwrap", fore->w_wrap ? '+' : '-'); + break; + case RC_FLOW: + if (*args) + { + if (args[0][0] == 'a') + { + fore->w_flow = (fore->w_flow & FLOW_AUTO) ? FLOW_AUTOFLAG |FLOW_AUTO|FLOW_NOW : FLOW_AUTOFLAG; + } + else + { + if (ParseOnOff(act, &n)) + break; + fore->w_flow = (fore->w_flow & FLOW_AUTO) | n; + } + } + else + { + if (fore->w_flow & FLOW_AUTOFLAG) + fore->w_flow = (fore->w_flow & FLOW_AUTO) | FLOW_NOW; + else if (fore->w_flow & FLOW_NOW) + fore->w_flow &= ~FLOW_NOW; + else + fore->w_flow = fore->w_flow ? FLOW_AUTOFLAG|FLOW_AUTO|FLOW_NOW : FLOW_AUTOFLAG; + } + SetFlow(fore->w_flow & FLOW_NOW); + if (msgok) + OutputMsg(0, "%cflow%s", (fore->w_flow & FLOW_NOW) ? '+' : '-', + (fore->w_flow & FLOW_AUTOFLAG) ? "(auto)" : ""); + break; +#ifdef MULTIUSER + case RC_DEFWRITELOCK: + if (args[0][0] == 'a') + nwin_default.wlock = WLOCK_AUTO; + else + { + if (ParseOnOff(act, &n)) + break; + nwin_default.wlock = n ? WLOCK_ON : WLOCK_OFF; + } + break; + case RC_WRITELOCK: + if (*args) + { + if (args[0][0] == 'a') + { + fore->w_wlock = WLOCK_AUTO; + } + else + { + if (ParseOnOff(act, &n)) + break; + fore->w_wlock = n ? WLOCK_ON : WLOCK_OFF; + } + /* + * user may have permission to change the writelock setting, + * but he may never aquire the lock himself without write permission + */ + if (!AclCheckPermWin(D_user, ACL_WRITE, fore)) + fore->w_wlockuser = D_user; + } + OutputMsg(0, "writelock %s", (fore->w_wlock == WLOCK_AUTO) ? "auto" : + ((fore->w_wlock == WLOCK_OFF) ? "off" : "on")); + break; +#endif + case RC_CLEAR: + ResetAnsiState(fore); + WriteString(fore, "\033[H\033[J", 6); + break; + case RC_RESET: + ResetAnsiState(fore); +#ifdef ZMODEM + if (fore->w_zdisplay) + zmodem_abort(fore, fore->w_zdisplay); +#endif + WriteString(fore, "\033c", 2); + break; + case RC_MONITOR: + n = fore->w_monitor != MON_OFF; +#ifdef MULTIUSER + if (display) + n = n && (ACLBYTE(fore->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id)); +#endif + if (ParseSwitch(act, &n)) + break; + if (n) + { +#ifdef MULTIUSER + if (display) /* we tell only this user */ + ACLBYTE(fore->w_mon_notify, D_user->u_id) |= ACLBIT(D_user->u_id); + else + for (i = 0; i < maxusercount; i++) + ACLBYTE(fore->w_mon_notify, i) |= ACLBIT(i); +#endif + if (fore->w_monitor == MON_OFF) + fore->w_monitor = MON_ON; + OutputMsg(0, "Window %d (%s) is now being monitored for all activity.", fore->w_number, fore->w_title); + } + else + { +#ifdef MULTIUSER + if (display) /* we remove only this user */ + ACLBYTE(fore->w_mon_notify, D_user->u_id) + &= ~ACLBIT(D_user->u_id); + else + for (i = 0; i < maxusercount; i++) + ACLBYTE(fore->w_mon_notify, i) &= ~ACLBIT(i); + for (i = maxusercount - 1; i >= 0; i--) + if (ACLBYTE(fore->w_mon_notify, i)) + break; + if (i < 0) +#endif + fore->w_monitor = MON_OFF; + OutputMsg(0, "Window %d (%s) is no longer being monitored for activity.", fore->w_number, fore->w_title); + } + break; +#ifdef MULTI + case RC_DISPLAYS: + display_displays(); + break; +#endif + case RC_WINDOWLIST: + if (!*args) + display_windows(0, WLIST_NUM, (struct win *)0); + else if (!strcmp(*args, "string")) + { + if (args[1]) + { + if (wliststr) + free(wliststr); + wliststr = SaveStr(args[1]); + } + if (msgok) + OutputMsg(0, "windowlist string is '%s'", wliststr); + } + else if (!strcmp(*args, "title")) + { + if (args[1]) + { + if (wlisttit) + free(wlisttit); + wlisttit = SaveStr(args[1]); + } + if (msgok) + OutputMsg(0, "windowlist title is '%s'", wlisttit); + } + else + { + int flag = 0; + int blank = 0; + for (i = 0; i < argc; i++) + if (!args[i]) + continue; + else if (!strcmp(args[i], "-m")) + flag |= WLIST_MRU; + else if (!strcmp(args[i], "-b")) + blank = 1; + else if (!strcmp(args[i], "-g")) + flag |= WLIST_NESTED; + else + { + OutputMsg(0, "usage: windowlist [-b] [-g] [-m] [string [string] | title [title]]"); + break; + } + if (i == argc) + display_windows(blank, flag, (struct win *)0); + } + break; + case RC_HELP: + if (argc == 2 && !strcmp(*args, "-c")) + { + struct action *ktabp; + if ((ktabp = FindKtab(args[1], 0)) == 0) + { + OutputMsg(0, "Unknown command class '%s'", args[1]); + break; + } + display_help(args[1], ktabp); + } + else + display_help((char *)0, ktab); + break; + case RC_LICENSE: + display_copyright(); + break; +#ifdef COPY_PASTE + case RC_COPY: + if (flayer->l_layfn != &WinLf) + { + OutputMsg(0, "Must be on a window layer"); + break; + } + MarkRoutine(); + WindowChanged(fore, 'P'); + break; + case RC_HISTORY: + { + static char *pasteargs[] = {".", 0}; + static int pasteargl[] = {1}; + + if (flayer->l_layfn != &WinLf) + { + OutputMsg(0, "Must be on a window layer"); + break; + } + if (GetHistory() == 0) + break; + if (user->u_plop.buf == NULL) + break; + args = pasteargs; + argl = pasteargl; + } + /*FALLTHROUGH*/ + case RC_PASTE: + { + char *ss, *dbuf, dch; + int l = 0; +# ifdef ENCODINGS + int enc = -1; +# endif + + /* + * without args we prompt for one(!) register to be pasted in the window + */ + if ((s = *args) == NULL) + { + Input("Paste from register:", 1, INP_RAW, ins_reg_fn, NULL, 0); + break; + } + if (args[1] == 0 && !fore) /* no window? */ + break; + /* + * with two arguments we paste into a destination register + * (no window needed here). + */ + if (args[1] && argl[1] != 1) + { + OutputMsg(0, "%s: paste destination: character, ^x, or (octal) \\032 expected.", + rc_name); + break; + } +# ifdef ENCODINGS + else if (fore) + enc = fore->w_encoding; +# endif + + /* + * measure length of needed buffer + */ + for (ss = s = *args; (ch = *ss); ss++) + { + if (ch == '.') + { +# ifdef ENCODINGS + if (enc == -1) + enc = user->u_plop.enc; + if (enc != user->u_plop.enc) + l += RecodeBuf((unsigned char *)user->u_plop.buf, user->u_plop.len, user->u_plop.enc, enc, (unsigned char *)0); + else +# endif + l += user->u_plop.len; + } + else + { +# ifdef ENCODINGS + if (enc == -1) + enc = plop_tab[(int)(unsigned char)ch].enc; + if (enc != plop_tab[(int)(unsigned char)ch].enc) + 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); + else +# endif + l += plop_tab[(int)(unsigned char)ch].len; + } + } + if (l == 0) + { + OutputMsg(0, "empty buffer"); + break; + } + /* + * shortcut: + * if there is only one source and the destination is a window, then + * pass a pointer rather than duplicating the buffer. + */ + if (s[1] == 0 && args[1] == 0) +# ifdef ENCODINGS + if (enc == (*s == '.' ? user->u_plop.enc : plop_tab[(int)(unsigned char)*s].enc)) +# endif + { + MakePaster(&fore->w_paster, *s == '.' ? user->u_plop.buf : plop_tab[(int)(unsigned char)*s].buf, l, 0); + break; + } + /* + * if no shortcut, we construct a buffer + */ + if ((dbuf = (char *)malloc(l)) == 0) + { + OutputMsg(0, "%s", strnomem); + break; + } + l = 0; + /* + * concatenate all sources into our own buffer, copy buffer is + * special and is skipped if no display exists. + */ + for (ss = s; (ch = *ss); ss++) + { + struct plop *pp = (ch == '.' ? &user->u_plop : &plop_tab[(int)(unsigned char)ch]); +#ifdef ENCODINGS + if (pp->enc != enc) + { + l += RecodeBuf((unsigned char *)pp->buf, pp->len, pp->enc, enc, (unsigned char *)dbuf + l); + continue; + } +#endif + bcopy(pp->buf, dbuf + l, pp->len); + l += pp->len; + } + /* + * when called with one argument we paste our buffer into the window + */ + if (args[1] == 0) + { + MakePaster(&fore->w_paster, dbuf, l, 1); + } + else + { + /* + * we have two arguments, the second is already in dch. + * use this as destination rather than the window. + */ + dch = args[1][0]; + if (dch == '.') + { + if (user->u_plop.buf != NULL) + UserFreeCopyBuffer(user); + user->u_plop.buf = dbuf; + user->u_plop.len = l; +#ifdef ENCODINGS + user->u_plop.enc = enc; +#endif + } + else + { + struct plop *pp = plop_tab + (int)(unsigned char)dch; + if (pp->buf) + free(pp->buf); + pp->buf = dbuf; + pp->len = l; +#ifdef ENCODINGS + pp->enc = enc; +#endif + } + } + break; + } + case RC_WRITEBUF: + if (!user->u_plop.buf) + { + OutputMsg(0, "empty buffer"); + break; + } +#ifdef ENCODINGS + { + struct plop oldplop; + + oldplop = user->u_plop; + if (args[0] && args[1] && !strcmp(args[0], "-e")) + { + int enc, l; + char *newbuf; + + enc = FindEncoding(args[1]); + if (enc == -1) + { + OutputMsg(0, "%s: writebuf: unknown encoding", rc_name); + break; + } + if (enc != oldplop.enc) + { + l = RecodeBuf((unsigned char *)oldplop.buf, oldplop.len, oldplop.enc, enc, (unsigned char *)0); + newbuf = malloc(l + 1); + if (!newbuf) + { + OutputMsg(0, "%s", strnomem); + break; + } + user->u_plop.len = RecodeBuf((unsigned char *)oldplop.buf, oldplop.len, oldplop.enc, enc, (unsigned char *)newbuf); + user->u_plop.buf = newbuf; + user->u_plop.enc = enc; + } + args += 2; + } +#endif + if (args[0] && args[1]) + OutputMsg(0, "%s: writebuf: too many arguments", rc_name); + else + WriteFile(user, args[0], DUMP_EXCHANGE); +#ifdef ENCODINGS + if (user->u_plop.buf != oldplop.buf) + free(user->u_plop.buf); + user->u_plop = oldplop; + } +#endif + break; + case RC_READBUF: +#ifdef ENCODINGS + i = fore ? fore->w_encoding : display ? display->d_encoding : 0; + if (args[0] && args[1] && !strcmp(args[0], "-e")) + { + i = FindEncoding(args[1]); + if (i == -1) + { + OutputMsg(0, "%s: readbuf: unknown encoding", rc_name); + break; + } + args += 2; + } +#endif + if (args[0] && args[1]) + { + OutputMsg(0, "%s: readbuf: too many arguments", rc_name); + break; + } + if ((s = ReadFile(args[0] ? args[0] : BufferFile, &n))) + { + if (user->u_plop.buf) + UserFreeCopyBuffer(user); + user->u_plop.len = n; + user->u_plop.buf = s; +#ifdef ENCODINGS + user->u_plop.enc = i; +#endif + } + break; + case RC_REMOVEBUF: + KillBuffers(); + break; + case RC_IGNORECASE: + (void)ParseSwitch(act, &search_ic); + if (msgok) + OutputMsg(0, "Will %signore case in searches", search_ic ? "" : "not "); + break; +#endif /* COPY_PASTE */ + case RC_ESCAPE: + if (*argl == 0) + SetEscape(user, -1, -1); + else if (*argl == 2) + SetEscape(user, (int)(unsigned char)args[0][0], (int)(unsigned char)args[0][1]); + else + { + OutputMsg(0, "%s: two characters required after escape.", rc_name); + break; + } + /* Change defescape if master user. This is because we only + * have one ktab. + */ + if (display && user != users) + break; + /* FALLTHROUGH */ + case RC_DEFESCAPE: + if (*argl == 0) + SetEscape(NULL, -1, -1); + else if (*argl == 2) + SetEscape(NULL, (int)(unsigned char)args[0][0], (int)(unsigned char)args[0][1]); + else + { + OutputMsg(0, "%s: two characters required after defescape.", rc_name); + break; + } +#ifdef MAPKEYS + CheckEscape(); +#endif + break; + case RC_CHDIR: + s = *args ? *args : home; + if (chdir(s) == -1) + OutputMsg(errno, "%s", s); + break; + case RC_SHELL: + case RC_DEFSHELL: + if (ParseSaveStr(act, &ShellProg) == 0) + ShellArgs[0] = ShellProg; + break; + case RC_HARDCOPYDIR: + if (*args) + (void)ParseSaveStr(act, &hardcopydir); + if (msgok) + OutputMsg(0, "hardcopydir is %s\n", hardcopydir && *hardcopydir ? hardcopydir : "<cwd>"); + break; + case RC_LOGFILE: + if (*args) + { + char buf[1024]; + if (args[1] && !(strcmp(*args, "flush"))) + { + log_flush = atoi(args[1]); + if (msgok) + OutputMsg(0, "log flush timeout set to %ds\n", log_flush); + break; + } + if (ParseSaveStr(act, &screenlogfile)) + break; + if (fore && fore->w_log) + if (DoStartLog(fore, buf, sizeof(buf))) + OutputMsg(0, "Error opening logfile \"%s\"", buf); + if (!msgok) + break; + } + OutputMsg(0, "logfile is '%s'", screenlogfile); + break; + case RC_LOGTSTAMP: + if (!*args || !strcmp(*args, "on") || !strcmp(*args, "off")) + { + if (ParseSwitch(act, &logtstamp_on) == 0 && msgok) + OutputMsg(0, "timestamps turned %s", logtstamp_on ? "on" : "off"); + } + else if (!strcmp(*args, "string")) + { + if (args[1]) + { + if (logtstamp_string) + free(logtstamp_string); + logtstamp_string = SaveStr(args[1]); + } + if (msgok) + OutputMsg(0, "logfile timestamp is '%s'", logtstamp_string); + } + else if (!strcmp(*args, "after")) + { + if (args[1]) + { + logtstamp_after = atoi(args[1]); + if (!msgok) + break; + } + OutputMsg(0, "timestamp printed after %ds\n", logtstamp_after); + } + else + OutputMsg(0, "usage: logtstamp [after [n]|string [str]|on|off]"); + break; + case RC_SHELLTITLE: + (void)ParseSaveStr(act, &nwin_default.aka); + break; + case RC_TERMCAP: + case RC_TERMCAPINFO: + case RC_TERMINFO: + if (!rc_name || !*rc_name) + OutputMsg(0, "Sorry, too late now. Place that in your .screenrc file."); + break; + case RC_SLEEP: + break; /* Already handled */ + case RC_TERM: + s = NULL; + if (ParseSaveStr(act, &s)) + break; + if (strlen(s) > MAXTERMLEN) + { + OutputMsg(0, "%s: term: argument too long ( < %d)", rc_name, MAXTERMLEN); + free(s); + break; + } + strncpy(screenterm, s, MAXTERMLEN); + screenterm[MAXTERMLEN] = '\0'; + free(s); + debug1("screenterm set to %s\n", screenterm); + MakeTermcap((display == 0)); + debug("new termcap made\n"); + break; + case RC_ECHO: + if (!msgok && (!rc_name || strcmp(rc_name, "-X"))) + break; + /* + * user typed ^A:echo... well, echo isn't FinishRc's job, + * but as he wanted to test us, we show good will + */ + if (argc > 1 && !strcmp(*args, "-n")) + { + args++; + argc--; + } + s = *args; + if (argc > 1 && !strcmp(*args, "-p")) + { + args++; + argc--; + s = *args; + if (s) + s = MakeWinMsg(s, fore, '%'); + } + if (s) + OutputMsg(0, "%s", s); + else + { + OutputMsg(0, "%s: 'echo [-n] [-p] \"string\"' expected.", rc_name); + queryflag = -1; + } + break; + case RC_BELL: + case RC_BELL_MSG: + if (*args == 0) + { + char buf[256]; + AddXChars(buf, sizeof(buf), BellString); + OutputMsg(0, "bell_msg is '%s'", buf); + break; + } + (void)ParseSaveStr(act, &BellString); + break; +#ifdef COPY_PASTE + case RC_BUFFERFILE: + if (*args == 0) + BufferFile = SaveStr(DEFAULT_BUFFERFILE); + else if (ParseSaveStr(act, &BufferFile)) + break; + if (msgok) + OutputMsg(0, "Bufferfile is now '%s'", BufferFile); + break; +#endif + case RC_ACTIVITY: + (void)ParseSaveStr(act, &ActivityString); + break; +#if defined(DETACH) && defined(POW_DETACH) + case RC_POW_DETACH_MSG: + if (*args == 0) + { + char buf[256]; + AddXChars(buf, sizeof(buf), PowDetachString); + OutputMsg(0, "pow_detach_msg is '%s'", buf); + break; + } + (void)ParseSaveStr(act, &PowDetachString); + break; +#endif +#if defined(UTMPOK) && defined(LOGOUTOK) + case RC_LOGIN: + n = fore->w_slot != (slot_t)-1; + if (*args && !strcmp(*args, "always")) + { + fore->w_lflag = 3; + if (!displays && n) + SlotToggle(n); + break; + } + if (*args && !strcmp(*args, "attached")) + { + fore->w_lflag = 1; + if (!displays && n) + SlotToggle(0); + break; + } + if (ParseSwitch(act, &n) == 0) + SlotToggle(n); + break; + case RC_DEFLOGIN: + if (!strcmp(*args, "always")) + nwin_default.lflag |= 2; + else if (!strcmp(*args, "attached")) + nwin_default.lflag &= ~2; + else + (void)ParseOnOff(act, &nwin_default.lflag); + break; +#endif + case RC_DEFFLOW: + if (args[0] && args[1] && args[1][0] == 'i') + { + iflag = 1; + for (display = displays; display; display = display->d_next) + { + if (!D_flow) + continue; +#if defined(TERMIO) || defined(POSIX) + D_NewMode.tio.c_cc[VINTR] = D_OldMode.tio.c_cc[VINTR]; + D_NewMode.tio.c_lflag |= ISIG; +#else /* TERMIO || POSIX */ + D_NewMode.m_tchars.t_intrc = D_OldMode.m_tchars.t_intrc; +#endif /* TERMIO || POSIX */ + SetTTY(D_userfd, &D_NewMode); + } + } + if (args[0] && args[0][0] == 'a') + nwin_default.flowflag = FLOW_AUTOFLAG; + else + (void)ParseOnOff(act, &nwin_default.flowflag); + break; + case RC_DEFWRAP: + (void)ParseOnOff(act, &nwin_default.wrap); + break; + case RC_DEFC1: + (void)ParseOnOff(act, &nwin_default.c1); + break; +#ifdef COLOR + case RC_DEFBCE: + (void)ParseOnOff(act, &nwin_default.bce); + break; +#endif + case RC_DEFGR: + (void)ParseOnOff(act, &nwin_default.gr); + break; + case RC_DEFMONITOR: + if (ParseOnOff(act, &n) == 0) + nwin_default.monitor = (n == 0) ? MON_OFF : MON_ON; + break; + case RC_DEFMOUSETRACK: + if (ParseOnOff(act, &n) == 0) + defmousetrack = (n == 0) ? 0 : 1000; + break; + case RC_MOUSETRACK: + if (!args[0]) + { + OutputMsg(0, "Mouse tracking for this display is turned %s", D_mousetrack ? "on" : "off"); + } + else if (ParseOnOff(act, &n) == 0) + { + D_mousetrack = n == 0 ? 0 : 1000; + if (D_fore) + MouseMode(D_fore->w_mouse); + } + break; + case RC_DEFSILENCE: + if (ParseOnOff(act, &n) == 0) + nwin_default.silence = (n == 0) ? SILENCE_OFF : SILENCE_ON; + break; + case RC_VERBOSE: + if (!*args) + OutputMsg(0, "W%s echo command when creating windows.", + VerboseCreate ? "ill" : "on't"); + else if (ParseOnOff(act, &n) == 0) + VerboseCreate = n; + break; + case RC_HARDSTATUS: + if (display) + { + OutputMsg(0, "%s", ""); /* wait till mintime (keep gcc quiet) */ + RemoveStatus(); + } + if (args[0] && strcmp(args[0], "on") && strcmp(args[0], "off")) + { + struct display *olddisplay = display; + int old_use, new_use = -1; + + s = args[0]; + if (!strncmp(s, "always", 6)) + s += 6; + if (!strcmp(s, "firstline")) + new_use = HSTATUS_FIRSTLINE; + else if (!strcmp(s, "lastline")) + new_use = HSTATUS_LASTLINE; + else if (!strcmp(s, "ignore")) + new_use = HSTATUS_IGNORE; + else if (!strcmp(s, "message")) + new_use = HSTATUS_MESSAGE; + else if (!strcmp(args[0], "string")) + { + if (!args[1]) + { + char buf[256]; + AddXChars(buf, sizeof(buf), hstatusstring); + OutputMsg(0, "hardstatus string is '%s'", buf); + break; + } + } + else + { + OutputMsg(0, "%s: usage: hardstatus [always]lastline|ignore|message|string [string]", rc_name); + break; + } + if (new_use != -1) + { + hardstatusemu = new_use | (s == args[0] ? 0 : HSTATUS_ALWAYS); + for (display = displays; display; display = display->d_next) + { + RemoveStatus(); + new_use = hardstatusemu & ~HSTATUS_ALWAYS; + if (D_HS && s == args[0]) + new_use = HSTATUS_HS; + ShowHStatus((char *)0); + old_use = D_has_hstatus; + D_has_hstatus = new_use; + if ((new_use == HSTATUS_LASTLINE && old_use != HSTATUS_LASTLINE) || (new_use != HSTATUS_LASTLINE && old_use == HSTATUS_LASTLINE)) + ChangeScreenSize(D_width, D_height, 1); + if ((new_use == HSTATUS_FIRSTLINE && old_use != HSTATUS_FIRSTLINE) || (new_use != HSTATUS_FIRSTLINE && old_use == HSTATUS_FIRSTLINE)) + ChangeScreenSize(D_width, D_height, 1); + RefreshHStatus(); + } + } + if (args[1]) + { + if (hstatusstring) + free(hstatusstring); + hstatusstring = SaveStr(args[1]); + for (display = displays; display; display = display->d_next) + RefreshHStatus(); + } + display = olddisplay; + break; + } + (void)ParseSwitch(act, &use_hardstatus); + if (msgok) + OutputMsg(0, "messages displayed on %s", use_hardstatus ? "hardstatus line" : "window"); + break; + case RC_CAPTION: + if (strcmp(args[0], "always") == 0 || strcmp(args[0], "splitonly") == 0) + { + struct display *olddisplay = display; + + captionalways = args[0][0] == 'a'; + for (display = displays; display; display = display->d_next) + ChangeScreenSize(D_width, D_height, 1); + display = olddisplay; + } + else if (strcmp(args[0], "string") == 0) + { + if (!args[1]) + { + char buf[256]; + AddXChars(buf, sizeof(buf), captionstring); + OutputMsg(0, "caption string is '%s'", buf); + break; + } + } + else + { + OutputMsg(0, "%s: usage: caption always|splitonly|string <string>", rc_name); + break; + } + if (!args[1]) + break; + if (captionstring) + free(captionstring); + captionstring = SaveStr(args[1]); + RedisplayDisplays(0); + break; + case RC_CONSOLE: + n = (console_window != 0); + if (ParseSwitch(act, &n)) + break; + if (TtyGrabConsole(fore->w_ptyfd, n, rc_name)) + break; + if (n == 0) + OutputMsg(0, "%s: releasing console %s", rc_name, HostName); + else if (console_window) + OutputMsg(0, "%s: stealing console %s from window %d (%s)", rc_name, + HostName, console_window->w_number, console_window->w_title); + else + OutputMsg(0, "%s: grabbing console %s", rc_name, HostName); + console_window = n ? fore : 0; + break; + case RC_ALLPARTIAL: + if (ParseOnOff(act, &all_norefresh)) + break; + if (!all_norefresh && fore) + Activate(-1); + if (msgok) + OutputMsg(0, all_norefresh ? "No refresh on window change!\n" : + "Window specific refresh\n"); + break; + case RC_PARTIAL: + (void)ParseSwitch(act, &n); + fore->w_norefresh = n; + break; + case RC_VBELL: + if (ParseSwitch(act, &visual_bell) || !msgok) + break; + if (visual_bell == 0) + OutputMsg(0, "switched to audible bell."); + else + OutputMsg(0, "switched to visual bell."); + break; + case RC_VBELLWAIT: + if (ParseNum1000(act, &VBellWait) == 0 && msgok) + OutputMsg(0, "vbellwait set to %.10g seconds", VBellWait/1000.); + break; + case RC_MSGWAIT: + if (ParseNum1000(act, &MsgWait) == 0 && msgok) + OutputMsg(0, "msgwait set to %.10g seconds", MsgWait/1000.); + break; + case RC_MSGMINWAIT: + if (ParseNum1000(act, &MsgMinWait) == 0 && msgok) + OutputMsg(0, "msgminwait set to %.10g seconds", MsgMinWait/1000.); + break; + case RC_SILENCEWAIT: + if (ParseNum(act, &SilenceWait)) + break; + if (SilenceWait < 1) + SilenceWait = 1; + for (p = windows; p; p = p->w_next) + p->w_silencewait = SilenceWait; + if (msgok) + OutputMsg(0, "silencewait set to %d seconds", SilenceWait); + break; + case RC_BUMPRIGHT: + if (fore->w_number < NextWindow()) + WindowChangeNumber(fore->w_number, NextWindow()); + break; + case RC_BUMPLEFT: + if (fore->w_number > PreviousWindow()) + WindowChangeNumber(fore->w_number, PreviousWindow()); + break; + case RC_COLLAPSE: + CollapseWindowlist(); + break; + case RC_NUMBER: + if (*args == 0) + OutputMsg(0, queryflag >= 0 ? "%d (%s)" : "This is window %d (%s).", fore->w_number, fore->w_title); + else + { + int old = fore->w_number; + int rel = 0, parse; + if (args[0][0] == '+') + rel = 1; + else if (args[0][0] == '-') + rel = -1; + if (rel) + ++act->args[0]; + parse = ParseNum(act, &n); + if (rel) + --act->args[0]; + if (parse) + break; + if (rel > 0) + n += old; + else if (rel < 0) + n = old - n; + if (!WindowChangeNumber(old, n)) + { + /* Window number could not be changed. */ + queryflag = -1; + return; + } + } + break; + + case RC_ZOMBIE_TIMEOUT: + if (argc != 1) { + Msg(0, "Setting zombie polling needs a timeout arg\n"); + break; + } + + nwin_default.poll_zombie_timeout = atoi(args[0]); + if (fore) + fore->w_poll_zombie_timeout = nwin_default.poll_zombie_timeout; + debug1("Setting zombie polling to %d\n", nwin_default.poll_zombie_timeout); + break; + + case RC_SORT: + if (fore) { + /* Better do not allow this. Not sure what the utmp stuff in number + * command above is for (you get four entries in e.g. /var/log/wtmp + * per number switch). But I don't know enough about this. + */ + Msg(0, "Sorting inside a window is not allowed. Push CTRL-a \" " + "and try again\n"); + break; + } + /* + * Simple sort algorithm: Look out for the smallest, put it + * to the first place, look out for the 2nd smallest, ... + */ + for (i = 0; i < maxwin ; i++) { + if (wtab[i] == NULL) + continue; + n = i; + + for (nr = i + 1; nr < maxwin; nr++) { + if (wtab[nr] == NULL) + continue; + debug2("Testing window %d and %d.\n", nr, n); + if (strcmp(wtab[nr]->w_title,wtab[n]->w_title) < 0) + n = nr; + } + + if (n != i) { + debug2("Exchange window %d and %d.\n", i, n); + p = wtab[n]; + wtab[n] = wtab[i]; + wtab[i] = p; + wtab[n]->w_number = n; + wtab[i]->w_number = i; +#ifdef MULTIUSER + /* exchange the acls for these windows. */ + AclWinSwap(i, n); +#endif + } + } + WindowChanged((struct win *)0, 0); + break; + + case RC_SILENCE: + n = fore->w_silence != 0; + i = fore->w_silencewait; + if (args[0] && (args[0][0] == '-' || (args[0][0] >= '0' && args[0][0] <= '9'))) + { + if (ParseNum(act, &i)) + break; + n = i > 0; + } + else if (ParseSwitch(act, &n)) + break; + if (n) + { +#ifdef MULTIUSER + if (display) /* we tell only this user */ + ACLBYTE(fore->w_lio_notify, D_user->u_id) |= ACLBIT(D_user->u_id); + else + for (n = 0; n < maxusercount; n++) + ACLBYTE(fore->w_lio_notify, n) |= ACLBIT(n); +#endif + fore->w_silencewait = i; + fore->w_silence = SILENCE_ON; + SetTimeout(&fore->w_silenceev, fore->w_silencewait * 1000); + evenq(&fore->w_silenceev); + + if (!msgok) + break; + OutputMsg(0, "The window is now being monitored for %d sec. silence.", fore->w_silencewait); + } + else + { +#ifdef MULTIUSER + if (display) /* we remove only this user */ + ACLBYTE(fore->w_lio_notify, D_user->u_id) + &= ~ACLBIT(D_user->u_id); + else + for (n = 0; n < maxusercount; n++) + ACLBYTE(fore->w_lio_notify, n) &= ~ACLBIT(n); + for (i = maxusercount - 1; i >= 0; i--) + if (ACLBYTE(fore->w_lio_notify, i)) + break; + if (i < 0) +#endif + { + fore->w_silence = SILENCE_OFF; + evdeq(&fore->w_silenceev); + } + if (!msgok) + break; + OutputMsg(0, "The window is no longer being monitored for silence."); + } + break; +#ifdef COPY_PASTE + case RC_DEFSCROLLBACK: + (void)ParseNum(act, &nwin_default.histheight); + break; + case RC_SCROLLBACK: + if (flayer->l_layfn == &MarkLf) + { + OutputMsg(0, "Cannot resize scrollback buffer in copy/scrollback mode."); + break; + } + (void)ParseNum(act, &n); + ChangeWindowSize(fore, fore->w_width, fore->w_height, n); + if (msgok) + OutputMsg(0, "scrollback set to %d", fore->w_histheight); + break; +#endif + case RC_SESSIONNAME: + if (*args == 0) + OutputMsg(0, "This session is named '%s'\n", SockName); + else + { + char buf[MAXPATHLEN]; + + s = 0; + if (ParseSaveStr(act, &s)) + break; + if (!*s || strlen(s) + (SockName - SockPath) > MAXPATHLEN - 13 || index(s, '/')) + { + OutputMsg(0, "%s: bad session name '%s'\n", rc_name, s); + free(s); + break; + } + strncpy(buf, SockPath, SockName - SockPath); + sprintf(buf + (SockName - SockPath), "%d.%s", (int)getpid(), s); + free(s); + if ((access(buf, F_OK) == 0) || (errno != ENOENT)) + { + OutputMsg(0, "%s: inappropriate path: '%s'.", rc_name, buf); + break; + } + if (rename(SockPath, buf)) + { + OutputMsg(errno, "%s: failed to rename(%s, %s)", rc_name, SockPath, buf); + break; + } + debug2("rename(%s, %s) done\n", SockPath, buf); + strcpy(SockPath, buf); + MakeNewEnv(); + WindowChanged((struct win *)0, 'S'); + } + break; + case RC_SETENV: + if (!args[0] || !args[1]) + { + debug1("RC_SETENV arguments missing: %s\n", args[0] ? args[0] : ""); + InputSetenv(args[0]); + } + else + { + xsetenv(args[0], args[1]); + MakeNewEnv(); + } + break; + case RC_UNSETENV: + unsetenv(*args); + MakeNewEnv(); + break; +#ifdef COPY_PASTE + case RC_DEFSLOWPASTE: + (void)ParseNum(act, &nwin_default.slow); + break; + case RC_SLOWPASTE: + if (*args == 0) + OutputMsg(0, fore->w_slowpaste ? + "Slowpaste in window %d is %d milliseconds." : + "Slowpaste in window %d is unset.", + fore->w_number, fore->w_slowpaste); + else if (ParseNum(act, &fore->w_slowpaste) == 0 && msgok) + OutputMsg(0, fore->w_slowpaste ? + "Slowpaste in window %d set to %d milliseconds." : + "Slowpaste in window %d now unset.", + fore->w_number, fore->w_slowpaste); + break; + case RC_MARKKEYS: + if (CompileKeys(*args, *argl, mark_key_tab)) + { + OutputMsg(0, "%s: markkeys: syntax error.", rc_name); + break; + } + debug1("markkeys %s\n", *args); + break; +# ifdef FONT + case RC_PASTEFONT: + if (ParseSwitch(act, &pastefont) == 0 && msgok) + OutputMsg(0, "Will %spaste font settings", pastefont ? "" : "not "); + break; +# endif + case RC_CRLF: + (void)ParseSwitch(act, &join_with_cr); + break; + case RC_COMPACTHIST: + if (ParseSwitch(act, &compacthist) == 0 && msgok) + OutputMsg(0, "%scompacting history lines", compacthist ? "" : "not "); + break; +#endif +#ifdef NETHACK + case RC_NETHACK: + (void)ParseOnOff(act, &nethackflag); + break; +#else + case RC_NETHACK: + Msg(0, "nethack disabled at build time"); + break; +#endif + case RC_HARDCOPY_APPEND: + (void)ParseOnOff(act, &hardcopy_append); + break; + case RC_VBELL_MSG: + if (*args == 0) + { + char buf[256]; + AddXChars(buf, sizeof(buf), VisualBellString); + OutputMsg(0, "vbell_msg is '%s'", buf); + break; + } + (void)ParseSaveStr(act, &VisualBellString); + debug1(" new vbellstr '%s'\n", VisualBellString); + break; + case RC_DEFMODE: + if (ParseBase(act, *args, &n, 8, "octal")) + break; + if (n < 0 || n > 0777) + { + OutputMsg(0, "%s: mode: Invalid tty mode %o", rc_name, n); + break; + } + TtyMode = n; + if (msgok) + OutputMsg(0, "Ttymode set to %03o", TtyMode); + break; + case RC_AUTODETACH: + (void)ParseOnOff(act, &auto_detach); + break; + case RC_STARTUP_MESSAGE: + (void)ParseOnOff(act, &default_startup); + break; +#ifdef PASSWORD + case RC_PASSWORD: + if (*args) + { + n = (*user->u_password) ? 1 : 0; + if (user->u_password != NullStr) free((char *)user->u_password); + user->u_password = SaveStr(*args); + if (!strcmp(user->u_password, "none")) + { + if (n) + OutputMsg(0, "Password checking disabled"); + free(user->u_password); + user->u_password = NullStr; + } + } + else + { + if (!fore) + { + OutputMsg(0, "%s: password: window required", rc_name); + break; + } + Input("New screen password:", 100, INP_NOECHO, pass1, display ? (char *)D_user : (char *)users, 0); + } + break; +#endif /* PASSWORD */ + case RC_BIND: + { + struct action *ktabp = ktab; + int kflag = 0; + + for (;;) + { + if (argc > 2 && !strcmp(*args, "-c")) + { + ktabp = FindKtab(args[1], 1); + if (ktabp == 0) + break; + args += 2; + argl += 2; + argc -= 2; + } + else if (argc > 1 && !strcmp(*args, "-k")) + { + kflag = 1; + args++; + argl++; + argc--; + } + else + break; + } +#ifdef MAPKEYS + if (kflag) + { + for (n = 0; n < KMAP_KEYS; n++) + if (strcmp(term[n + T_CAPS].tcname, *args) == 0) + break; + if (n == KMAP_KEYS) + { + OutputMsg(0, "%s: bind: unknown key '%s'", rc_name, *args); + break; + } + n += 256; + } + else +#endif + if (*argl != 1) + { + OutputMsg(0, "%s: bind: character, ^x, or (octal) \\032 expected.", rc_name); + break; + } + else + n = (unsigned char)args[0][0]; + + if (args[1]) + { + if ((i = FindCommnr(args[1])) == RC_ILLEGAL) + { + OutputMsg(0, "%s: bind: unknown command '%s'", rc_name, args[1]); + break; + } + if (CheckArgNum(i, args + 2) < 0) + break; + ClearAction(&ktabp[n]); + SaveAction(ktabp + n, i, args + 2, argl + 2); + } + else + ClearAction(&ktabp[n]); + } + break; +#ifdef MAPKEYS + case RC_BINDKEY: + { + struct action *newact; + int newnr, fl = 0, kf = 0, af = 0, df = 0, mf = 0; + struct display *odisp = display; + int used = 0; + struct kmap_ext *kme = NULL; + + for (; *args && **args == '-'; args++, argl++) + { + if (strcmp(*args, "-t") == 0) + fl = KMAP_NOTIMEOUT; + else if (strcmp(*args, "-k") == 0) + kf = 1; + else if (strcmp(*args, "-a") == 0) + af = 1; + else if (strcmp(*args, "-d") == 0) + df = 1; + else if (strcmp(*args, "-m") == 0) + mf = 1; + else if (strcmp(*args, "--") == 0) + { + args++; + argl++; + break; + } + else + { + OutputMsg(0, "%s: bindkey: invalid option %s", rc_name, *args); + return; + } + } + if (df && mf) + { + OutputMsg(0, "%s: bindkey: -d does not work with -m", rc_name); + break; + } + if (*args == 0) + { + if (mf) + display_bindkey("Edit mode", mmtab); + else if (df) + display_bindkey("Default", dmtab); + else + display_bindkey("User", umtab); + break; + } + if (kf == 0) + { + if (af) + { + OutputMsg(0, "%s: bindkey: -a only works with -k", rc_name); + break; + } + if (*argl == 0) + { + OutputMsg(0, "%s: bindkey: empty string makes no sense", rc_name); + break; + } + for (i = 0, kme = kmap_exts; i < kmap_extn; i++, kme++) + if (kme->str == 0) + { + if (args[1]) + break; + } + else + if (*argl == (kme->fl & ~KMAP_NOTIMEOUT) && bcmp(kme->str, *args, *argl) == 0) + break; + if (i == kmap_extn) + { + if (!args[1]) + { + OutputMsg(0, "%s: bindkey: keybinding not found", rc_name); + break; + } + kmap_extn += 8; + kmap_exts = (struct kmap_ext *)xrealloc((char *)kmap_exts, kmap_extn * sizeof(*kmap_exts)); + kme = kmap_exts + i; + bzero((char *)kme, 8 * sizeof(*kmap_exts)); + for (; i < kmap_extn; i++, kme++) + { + kme->str = 0; + kme->dm.nr = kme->mm.nr = kme->um.nr = RC_ILLEGAL; + kme->dm.args = kme->mm.args = kme->um.args = noargs; + kme->dm.argl = kme->mm.argl = kme->um.argl = 0; + } + i -= 8; + kme -= 8; + } + if (df == 0 && kme->dm.nr != RC_ILLEGAL) + used = 1; + if (mf == 0 && kme->mm.nr != RC_ILLEGAL) + used = 1; + if ((df || mf) && kme->um.nr != RC_ILLEGAL) + used = 1; + i += KMAP_KEYS + KMAP_AKEYS; + newact = df ? &kme->dm : mf ? &kme->mm : &kme->um; + } + else + { + for (i = T_CAPS; i < T_OCAPS; i++) + if (strcmp(term[i].tcname, *args) == 0) + break; + if (i == T_OCAPS) + { + OutputMsg(0, "%s: bindkey: unknown key '%s'", rc_name, *args); + break; + } + if (af && i >= T_CURSOR && i < T_OCAPS) + i -= T_CURSOR - KMAP_KEYS; + else + i -= T_CAPS; + newact = df ? &dmtab[i] : mf ? &mmtab[i] : &umtab[i]; + } + if (args[1]) + { + if ((newnr = FindCommnr(args[1])) == RC_ILLEGAL) + { + OutputMsg(0, "%s: bindkey: unknown command '%s'", rc_name, args[1]); + break; + } + if (CheckArgNum(newnr, args + 2) < 0) + break; + ClearAction(newact); + SaveAction(newact, newnr, args + 2, argl + 2); + if (kf == 0 && args[1]) + { + if (kme->str) + free(kme->str); + kme->str = SaveStrn(*args, *argl); + kme->fl = fl | *argl; + } + } + else + ClearAction(newact); + for (display = displays; display; display = display->d_next) + remap(i, args[1] ? 1 : 0); + if (kf == 0 && !args[1]) + { + if (!used && kme->str) + { + free(kme->str); + kme->str = 0; + kme->fl = 0; + } + } + display = odisp; + } + break; + case RC_MAPTIMEOUT: + if (*args) + { + if (ParseNum(act, &n)) + break; + if (n < 0) + { + OutputMsg(0, "%s: maptimeout: illegal time %d", rc_name, n); + break; + } + maptimeout = n; + } + if (*args == 0 || msgok) + OutputMsg(0, "maptimeout is %dms", maptimeout); + break; + case RC_MAPNOTNEXT: + D_dontmap = 1; + break; + case RC_MAPDEFAULT: + D_mapdefault = 1; + break; +#endif +#ifdef MULTIUSER + case RC_ACLCHG: + case RC_ACLADD: + case RC_ADDACL: + case RC_CHACL: + UsersAcl(NULL, argc, args); + break; + case RC_ACLDEL: + if (UserDel(args[0], NULL)) + break; + if (msgok) + OutputMsg(0, "%s removed from acl database", args[0]); + break; + case RC_ACLGRP: + /* + * modify a user to gain or lose rights granted to a group. + * This group is actually a normal user whose rights were defined + * with chacl in the usual way. + */ + if (args[1]) + { + if (strcmp(args[1], "none")) /* link a user to another user */ + { + if (AclLinkUser(args[0], args[1])) + break; + if (msgok) + OutputMsg(0, "User %s joined acl-group %s", args[0], args[1]); + } + else /* remove all groups from user */ + { + struct acluser *u; + struct aclusergroup *g; + + if (!(u = *FindUserPtr(args[0]))) + break; + while ((g = u->u_group)) + { + u->u_group = g->next; + free((char *)g); + } + } + } + else /* show all groups of user */ + { + char buf[256], *p = buf; + int ngroups = 0; + struct acluser *u; + struct aclusergroup *g; + + if (!(u = *FindUserPtr(args[0]))) + { + if (msgok) + OutputMsg(0, "User %s does not exist.", args[0]); + break; + } + g = u->u_group; + while (g) + { + ngroups++; + sprintf(p, "%s ", g->u->u_name); + p += strlen(p); + if (p > buf+200) + break; + g = g->next; + } + if (ngroups) + *(--p) = '\0'; + OutputMsg(0, "%s's group%s: %s.", args[0], (ngroups == 1) ? "" : "s", + (ngroups == 0) ? "none" : buf); + } + break; + case RC_ACLUMASK: + case RC_UMASK: + while ((s = *args++)) + { + char *err = 0; + + if (AclUmask(display ? D_user : users, s, &err)) + OutputMsg(0, "umask: %s\n", err); + } + break; + case RC_MULTIUSER: + if (ParseOnOff(act, &n)) + break; + multi = n ? "" : 0; + chsock(); + if (msgok) + OutputMsg(0, "Multiuser mode %s", multi ? "enabled" : "disabled"); + break; +#endif /* MULTIUSER */ +#ifdef PSEUDOS + case RC_EXEC: + winexec(args); + break; +#endif +#ifdef MULTI + case RC_NONBLOCK: + i = D_nonblock >= 0; + if (*args && ((args[0][0] >= '0' && args[0][0] <= '9') || args[0][0] == '.')) + { + if (ParseNum1000(act, &i)) + break; + } + else if (!ParseSwitch(act, &i)) + i = i == 0 ? -1 : 1000; + else + break; + if (msgok && i == -1) + OutputMsg(0, "display set to blocking mode"); + else if (msgok && i == 0) + OutputMsg(0, "display set to nonblocking mode, no timeout"); + else if (msgok) + OutputMsg(0, "display set to nonblocking mode, %.10gs timeout", i/1000.); + D_nonblock = i; + if (D_nonblock <= 0) + evdeq(&D_blockedev); + break; + case RC_DEFNONBLOCK: + if (*args && ((args[0][0] >= '0' && args[0][0] <= '9') || args[0][0] == '.')) + { + if (ParseNum1000(act, &defnonblock)) + break; + } + else if (!ParseOnOff(act, &defnonblock)) + defnonblock = defnonblock == 0 ? -1 : 1000; + else + break; + if (display && *rc_name) + { + D_nonblock = defnonblock; + if (D_nonblock <= 0) + evdeq(&D_blockedev); + } + break; +#endif + case RC_GR: +#ifdef ENCODINGS + if (fore->w_gr == 2) + fore->w_gr = 0; +#endif + if (ParseSwitch(act, &fore->w_gr) == 0 && msgok) + OutputMsg(0, "Will %suse GR", fore->w_gr ? "" : "not "); +#ifdef ENCODINGS + if (fore->w_gr == 0 && fore->w_FontE) + fore->w_gr = 2; +#endif + break; + case RC_C1: + if (ParseSwitch(act, &fore->w_c1) == 0 && msgok) + OutputMsg(0, "Will %suse C1", fore->w_c1 ? "" : "not "); + break; +#ifdef COLOR + case RC_BCE: + if (ParseSwitch(act, &fore->w_bce) == 0 && msgok) + OutputMsg(0, "Will %serase with background color", fore->w_bce ? "" : "not "); + break; +#endif +#ifdef ENCODINGS + case RC_KANJI: + case RC_ENCODING: +#ifdef UTF8 + if (*args && !strcmp(args[0], "-d")) + { + if (!args[1]) + OutputMsg(0, "encodings directory is %s", screenencodings ? screenencodings : "<unset>"); + else + { + free(screenencodings); + screenencodings = SaveStr(args[1]); + } + break; + } + if (*args && !strcmp(args[0], "-l")) + { + if (!args[1]) + OutputMsg(0, "encoding: -l: argument required"); + else if (LoadFontTranslation(-1, args[1])) + OutputMsg(0, "encoding: could not load utf8 encoding file"); + else if (msgok) + OutputMsg(0, "encoding: utf8 encoding file loaded"); + break; + } +#else + if (*args && (!strcmp(args[0], "-l") || !strcmp(args[0], "-d"))) + { + if (msgok) + OutputMsg(0, "encoding: screen is not compiled for UTF-8."); + break; + } +#endif + for (i = 0; i < 2; i++) + { + if (args[i] == 0) + break; + if (!strcmp(args[i], ".")) + continue; + n = FindEncoding(args[i]); + if (n == -1) + { + OutputMsg(0, "encoding: unknown encoding '%s'", args[i]); + break; + } + if (i == 0 && fore) + { + WinSwitchEncoding(fore, n); + ResetCharsets(fore); + } + else if (i && display) + D_encoding = n; + } + break; + case RC_DEFKANJI: + case RC_DEFENCODING: + n = FindEncoding(*args); + if (n == -1) + { + OutputMsg(0, "defencoding: unknown encoding '%s'", *args); + break; + } + nwin_default.encoding = n; + break; +#endif + +#ifdef UTF8 + case RC_DEFUTF8: + n = nwin_default.encoding == UTF8; + if (ParseSwitch(act, &n) == 0) + { + nwin_default.encoding = n ? UTF8 : 0; + if (msgok) + OutputMsg(0, "Will %suse UTF-8 encoding for new windows", n ? "" : "not "); + } + break; + case RC_UTF8: + for (i = 0; i < 2; i++) + { + if (i && args[i] == 0) + break; + if (args[i] == 0) + n = fore->w_encoding != UTF8; + else if (strcmp(args[i], "off") == 0) + n = 0; + else if (strcmp(args[i], "on") == 0) + n = 1; + else + { + OutputMsg(0, "utf8: illegal argument (%s)", args[i]); + break; + } + if (i == 0) + { + WinSwitchEncoding(fore, n ? UTF8 : 0); + if (msgok) + OutputMsg(0, "Will %suse UTF-8 encoding", n ? "" : "not "); + } + else if (display) + D_encoding = n ? UTF8 : 0; + if (args[i] == 0) + break; + } + break; +#endif + + case RC_PRINTCMD: + if (*args) + { + if (printcmd) + free(printcmd); + printcmd = 0; + if (**args) + printcmd = SaveStr(*args); + } + if (*args == 0 || msgok) + { + if (printcmd) + OutputMsg(0, "using '%s' as print command", printcmd); + else + OutputMsg(0, "using termcap entries for printing"); + break; + } + break; + + case RC_DIGRAPH: + if (argl && argl[0] > 0 && args[1] && argl[1] > 0) + { + if (argl[0] != 2) + { + OutputMsg(0, "Two characters expected to define a digraph"); + break; + } + i = digraph_find(args[0]); + digraphs[i].d[0] = args[0][0]; + digraphs[i].d[1] = args[0][1]; + if (!parse_input_int(args[1], argl[1], &digraphs[i].value)) + { + if (!(digraphs[i].value = atoi(args[1]))) + { + if (!args[1][1]) + digraphs[i].value = (int)args[1][0]; +#ifdef UTF8 + else + { + int t; + unsigned char *s = (unsigned char *)args[1]; + digraphs[i].value = 0; + while (*s) + { + t = FromUtf8(*s++, &digraphs[i].value); + if (t == -1) + continue; + if (t == -2) + digraphs[i].value = 0; + else + digraphs[i].value = t; + break; + } + } +#endif + } + } + break; + } + Input("Enter digraph: ", 10, INP_EVERY, digraph_fn, NULL, 0); + if (*args && **args) + { + s = *args; + n = strlen(s); + LayProcess(&s, &n); + } + break; + + case RC_DEFHSTATUS: + if (*args == 0) + { + char buf[256]; + *buf = 0; + if (nwin_default.hstatus) + AddXChars(buf, sizeof(buf), nwin_default.hstatus); + OutputMsg(0, "default hstatus is '%s'", buf); + break; + } + (void)ParseSaveStr(act, &nwin_default.hstatus); + if (*nwin_default.hstatus == 0) + { + free(nwin_default.hstatus); + nwin_default.hstatus = 0; + } + break; + case RC_HSTATUS: + (void)ParseSaveStr(act, &fore->w_hstatus); + if (*fore->w_hstatus == 0) + { + free(fore->w_hstatus); + fore->w_hstatus = 0; + } + WindowChanged(fore, 'h'); + break; + +#ifdef FONT + case RC_DEFCHARSET: + case RC_CHARSET: + if (*args == 0) + { + char buf[256]; + *buf = 0; + if (nwin_default.charset) + AddXChars(buf, sizeof(buf), nwin_default.charset); + OutputMsg(0, "default charset is '%s'", buf); + break; + } + n = strlen(*args); + if (n == 0 || n > 6) + { + OutputMsg(0, "%s: %s: string has illegal size.", rc_name, comms[nr].name); + break; + } + if (n > 4 && ( + ((args[0][4] < '0' || args[0][4] > '3') && args[0][4] != '.') || + ((args[0][5] < '0' || args[0][5] > '3') && args[0][5] && args[0][5] != '.'))) + { + OutputMsg(0, "%s: %s: illegal mapping number.", rc_name, comms[nr].name); + break; + } + if (nr == RC_CHARSET) + { + SetCharsets(fore, *args); + break; + } + if (nwin_default.charset) + free(nwin_default.charset); + nwin_default.charset = SaveStr(*args); + break; +#endif +#ifdef COLOR + case RC_ATTRCOLOR: + s = args[0]; + if (*s >= '0' && *s <= '9') + i = *s - '0'; + else + for (i = 0; i < 8; i++) + if (*s == "dubrsBiI"[i]) + break; + s++; + nr = 0; + if (*s && s[1] && !s[2]) + { + if (*s == 'd' && s[1] == 'd') + nr = 3; + else if (*s == '.' && s[1] == 'd') + nr = 2; + else if (*s == 'd' && s[1] == '.') + nr = 1; + else if (*s != '.' || s[1] != '.') + s--; + s += 2; + } + if (*s || i < 0 || i >= 8) + { + OutputMsg(0, "%s: attrcolor: unknown attribute '%s'.", rc_name, args[0]); + break; + } + n = 0; + if (args[1]) + n = ParseAttrColor(args[1], args[2], 1); + if (n == -1) + break; + attr2color[i][nr] = n; + n = 0; + for (i = 0; i < 8; i++) + if (attr2color[i][0] || attr2color[i][1] || attr2color[i][2] || attr2color[i][3]) + n |= 1 << i; + nattr2color = n; + break; +#endif + case RC_RENDITION: + i = -1; + if (strcmp(args[0], "bell") == 0) + { + i = REND_BELL; + } + else if (strcmp(args[0], "monitor") == 0) + { + i = REND_MONITOR; + } + else if (strcmp(args[0], "silence") == 0) + { + i = REND_SILENCE; + } + else if (strcmp(args[0], "so") != 0) + { + OutputMsg(0, "Invalid option '%s' for rendition", args[0]); + break; + } + + ++args; + ++argl; + + if (i != -1) + { + renditions[i] = ParseAttrColor(args[0], args[1], 1); + WindowChanged((struct win *)0, 'w'); + WindowChanged((struct win *)0, 'W'); + WindowChanged((struct win *)0, 0); + break; + } + + /* We are here, means we want to set the sorendition. */ + /* FALLTHROUGH*/ + case RC_SORENDITION: + i = 0; + if (*args) + { + i = ParseAttrColor(*args, args[1], 1); + if (i == -1) + break; + ApplyAttrColor(i, &mchar_so); + WindowChanged((struct win *)0, 0); + debug2("--> %x %x\n", mchar_so.attr, mchar_so.color); + } + if (msgok) +#ifdef COLOR + OutputMsg(0, "Standout attributes 0x%02x color 0x%02x", (unsigned char)mchar_so.attr, 0x99 ^ (unsigned char)mchar_so.color); +#else + OutputMsg(0, "Standout attributes 0x%02x ", (unsigned char)mchar_so.attr); +#endif + break; + + case RC_SOURCE: + do_source(*args); + break; + +#ifdef MULTIUSER + case RC_SU: + s = NULL; + if (!*args) + { + OutputMsg(0, "%s:%s screen login", HostName, SockPath); + InputSu(D_fore, &D_user, NULL); + } + else if (!args[1]) + InputSu(D_fore, &D_user, args[0]); + else if (!args[2]) + s = DoSu(&D_user, args[0], args[1], "\377"); + else + s = DoSu(&D_user, args[0], args[1], args[2]); + if (s) + OutputMsg(0, "%s", s); + break; +#endif /* MULTIUSER */ + case RC_SPLIT: + s = args[0]; + if (s && !strcmp(s, "-v")) + AddCanvas(SLICE_HORI); + else + AddCanvas(SLICE_VERT); + Activate(-1); + break; + case RC_REMOVE: + RemCanvas(); + Activate(-1); + break; + case RC_ONLY: + OneCanvas(); + Activate(-1); + break; + case RC_FIT: + D_forecv->c_xoff = D_forecv->c_xs; + D_forecv->c_yoff = D_forecv->c_ys; + RethinkViewportOffsets(D_forecv); + ResizeLayer(D_forecv->c_layer, D_forecv->c_xe - D_forecv->c_xs + 1, D_forecv->c_ye - D_forecv->c_ys + 1, 0); + flayer = D_forecv->c_layer; + LaySetCursor(); + break; + case RC_FOCUS: + { + struct canvas *cv = 0; + if (!*args || !strcmp(*args, "next")) + cv = D_forecv->c_next ? D_forecv->c_next : D_cvlist; + else if (!strcmp(*args, "prev")) + { + for (cv = D_cvlist; cv->c_next && cv->c_next != D_forecv; cv = cv->c_next) + ; + } + else if (!strcmp(*args, "top")) + cv = D_cvlist; + else if (!strcmp(*args, "bottom")) + { + for (cv = D_cvlist; cv->c_next; cv = cv->c_next) + ; + } + else if (!strcmp(*args, "up")) + cv = FindCanvas(D_forecv->c_xs, D_forecv->c_ys - 1); + else if (!strcmp(*args, "down")) + cv = FindCanvas(D_forecv->c_xs, D_forecv->c_ye + 2); + else if (!strcmp(*args, "left")) + cv = FindCanvas(D_forecv->c_xs - 1, D_forecv->c_ys); + else if (!strcmp(*args, "right")) + cv = FindCanvas(D_forecv->c_xe + 1, D_forecv->c_ys); + else + { + OutputMsg(0, "%s: usage: focus [next|prev|up|down|left|right|top|bottom]", rc_name); + break; + } + SetForeCanvas(display, cv); + } + break; + case RC_RESIZE: + i = 0; + if (D_forecv->c_slorient == SLICE_UNKN) + { + OutputMsg(0, "resize: need more than one region"); + break; + } + for (; *args; args++) + { + if (!strcmp(*args, "-h")) + i |= RESIZE_FLAG_H; + else if (!strcmp(*args, "-v")) + i |= RESIZE_FLAG_V; + else if (!strcmp(*args, "-b")) + i |= RESIZE_FLAG_H | RESIZE_FLAG_V; + else if (!strcmp(*args, "-p")) + i |= D_forecv->c_slorient == SLICE_VERT ? RESIZE_FLAG_H : RESIZE_FLAG_V; + else if (!strcmp(*args, "-l")) + i |= RESIZE_FLAG_L; + else + break; + } + if (*args && args[1]) + { + OutputMsg(0, "%s: usage: resize [-h] [-v] [-l] [num]\n", rc_name); + break; + } + if (*args) + ResizeRegions(*args, i); + else + Input(resizeprompts[i], 20, INP_EVERY, ResizeFin, (char*)0, i); + break; + case RC_SETSID: + (void)ParseSwitch(act, &separate_sids); + break; + case RC_EVAL: + args = SaveArgs(args); + for (i = 0; args[i]; i++) + { + if (args[i][0]) + Colonfin(args[i], strlen(args[i]), (char *)0); + free(args[i]); + } + free(args); + break; + case RC_ALTSCREEN: + (void)ParseSwitch(act, &use_altscreen); + if (msgok) + OutputMsg(0, "Will %sdo alternate screen switching", use_altscreen ? "" : "not "); + break; + case RC_MAXWIN: + if (!args[0]) + { + OutputMsg(0, "maximum windows allowed: %d", maxwin); + break; + } + if (ParseNum(act, &n)) + break; + if (n < 1) + OutputMsg(0, "illegal maxwin number specified"); + else if (n > 2048) + OutputMsg(0, "maximum 2048 windows allowed"); + else if (n > maxwin && windows) + OutputMsg(0, "may increase maxwin only when there's no window"); + else + { + if (!windows) + { + wtab = realloc(wtab, n * sizeof(struct win *)); + bzero(wtab, n * sizeof(struct win *)); + } + maxwin = n; + } + break; + case RC_BACKTICK: + if (ParseBase(act, *args, &n, 10, "decimal")) + break; + if (!args[1]) + setbacktick(n, 0, 0, (char **)0); + else + { + int lifespan, tick; + if (argc < 4) + { + OutputMsg(0, "%s: usage: backtick num [lifespan tick cmd args...]", rc_name); + break; + } + if (ParseBase(act, args[1], &lifespan, 10, "decimal")) + break; + if (ParseBase(act, args[2], &tick, 10, "decimal")) + break; + setbacktick(n, lifespan, tick, SaveArgs(args + 3)); + } + WindowChanged(0, '`'); + break; + case RC_BLANKER: +#ifdef BLANKER_PRG + if (blankerprg) + { + RunBlanker(blankerprg); + break; + } +#endif + ClearAll(); + CursorVisibility(-1); + D_blocked = 4; + break; +#ifdef BLANKER_PRG + case RC_BLANKERPRG: + if (!args[0]) + { + if (blankerprg) + { + char path[MAXPATHLEN]; + char *p = path, **pp; + for (pp = blankerprg; *pp; pp++) + p += snprintf(p, sizeof(path) - (p - path) - 1, "%s ", *pp); + *(p - 1) = '\0'; + OutputMsg(0, "blankerprg: %s", path); + } + else + OutputMsg(0, "No blankerprg set."); + break; + } + if (blankerprg) + { + char **pp; + for (pp = blankerprg; *pp; pp++) + free(*pp); + free(blankerprg); + blankerprg = 0; + } + if (args[0][0]) + blankerprg = SaveArgs(args); + break; +#endif + case RC_IDLE: + if (*args) + { + struct display *olddisplay = display; + if (!strcmp(*args, "off")) + idletimo = 0; + else if (args[0][0]) + idletimo = atoi(*args) * 1000; + if (argc > 1) + { + if ((i = FindCommnr(args[1])) == RC_ILLEGAL) + { + OutputMsg(0, "%s: idle: unknown command '%s'", rc_name, args[1]); + break; + } + if (CheckArgNum(i, args + 2) < 0) + break; + ClearAction(&idleaction); + SaveAction(&idleaction, i, args + 2, argl + 2); + } + for (display = displays; display; display = display->d_next) + ResetIdle(); + display = olddisplay; + } + if (msgok) + { + if (idletimo) + OutputMsg(0, "idle timeout %ds, %s", idletimo / 1000, comms[idleaction.nr].name); + else + OutputMsg(0, "idle off"); + } + break; + case RC_FOCUSMINSIZE: + for (i = 0; i < 2 && args[i]; i++) + { + if (!strcmp(args[i], "max") || !strcmp(args[i], "_")) + n = -1; + else + n = atoi(args[i]); + if (i == 0) + focusminwidth = n; + else + focusminheight = n; + } + if (msgok) + { + char b[2][20]; + for (i = 0; i < 2; i++) + { + n = i == 0 ? focusminwidth : focusminheight; + if (n == -1) + strcpy(b[i], "max"); + else + sprintf(b[i], "%d", n); + } + OutputMsg(0, "focus min size is %s %s\n", b[0], b[1]); + } + break; + case RC_GROUP: + if (*args) + { + fore->w_group = 0; + if (args[0][0]) + { + fore->w_group = WindowByName(*args); + if (fore->w_group == fore || (fore->w_group && fore->w_group->w_type != W_TYPE_GROUP)) + fore->w_group = 0; + } + WindowChanged((struct win *)0, 'w'); + WindowChanged((struct win *)0, 'W'); + WindowChanged((struct win *)0, 0); + } + if (msgok) + { + if (fore->w_group) + OutputMsg(0, "window group is %d (%s)\n", fore->w_group->w_number, fore->w_group->w_title); + else + OutputMsg(0, "window belongs to no group"); + } + break; + case RC_LAYOUT: + // A number of the subcommands for "layout" are ignored, or not processed correctly when there + // is no attached display. + + if (!strcmp(args[0], "title")) + { + if (!display) + { + if (!args[1]) // There is no display, and there is no new title. Ignore. + break; + if (!layout_attach || layout_attach == &layout_last_marker) + layout_attach = CreateLayout(args[1], 0); + else + RenameLayout(layout_attach, args[1]); + break; + } + + if (!D_layout) + { + OutputMsg(0, "not on a layout"); + break; + } + if (!args[1]) + { + OutputMsg(0, "current layout is %d (%s)", D_layout->lay_number, D_layout->lay_title); + break; + } + RenameLayout(D_layout, args[1]); + } + else if (!strcmp(args[0], "number")) + { + if (!display) + { + if (args[1] && layout_attach && layout_attach != &layout_last_marker) + RenumberLayout(layout_attach, atoi(args[1])); + break; + } + + if (!D_layout) + { + OutputMsg(0, "not on a layout"); + break; + } + if (!args[1]) + { + OutputMsg(0, "This is layout %d (%s).\n", D_layout->lay_number, D_layout->lay_title); + break; + } + RenumberLayout(D_layout, atoi(args[1])); + break; + } + else if (!strcmp(args[0], "autosave")) + { + if (!display) + { + if (args[1] && layout_attach && layout_attach != &layout_last_marker) + { + if (!strcmp(args[1], "on")) + layout_attach->lay_autosave = 1; + else if (!strcmp(args[1], "off")) + layout_attach->lay_autosave = 0; + } + break; + } + + if (!D_layout) + { + OutputMsg(0, "not on a layout"); + break; + } + if (args[1]) + { + if (!strcmp(args[1], "on")) + D_layout->lay_autosave = 1; + else if (!strcmp(args[1], "off")) + D_layout->lay_autosave = 0; + else + { + OutputMsg(0, "invalid argument. Give 'on' or 'off"); + break; + } + } + if (msgok) + OutputMsg(0, "autosave is %s", D_layout->lay_autosave ? "on" : "off"); + } + else if (!strcmp(args[0], "new")) + { + char *t = args[1]; + n = 0; + if (t) + { + while (*t >= '0' && *t <= '9') + t++; + if (t != args[1] && (!*t || *t == ':')) + { + n = atoi(args[1]); + if (*t) + t++; + } + else + t = args[1]; + } + if (!t || !*t) + t = "layout"; + NewLayout(t, n); + Activate(-1); + } + else if (!strcmp(args[0], "save")) + { + if (!args[1]) + { + OutputMsg(0, "usage: layout save <name>"); + break; + } + if (display) + SaveLayout(args[1], &D_canvas); + } + else if (!strcmp(args[0], "select")) + { + if (!display) + { + if (args[1]) + layout_attach = FindLayout(args[1]); + break; + } + if (!args[1]) + { + Input("Switch to layout: ", 20, INP_COOKED, SelectLayoutFin, NULL, 0); + break; + } + SelectLayoutFin(args[1], strlen(args[1]), (char *)0); + } + else if (!strcmp(args[0], "next")) + { + if (!display) + { + if (layout_attach && layout_attach != &layout_last_marker) + layout_attach = layout_attach->lay_next ? layout_attach->lay_next : layouts;; + break; + } + struct layout *lay = D_layout; + if (lay) + lay = lay->lay_next ? lay->lay_next : layouts; + else + lay = layouts; + if (!lay) + { + OutputMsg(0, "no layout defined"); + break; + } + if (lay == D_layout) + break; + LoadLayout(lay, &D_canvas); + Activate(-1); + } + else if (!strcmp(args[0], "prev")) + { + struct layout *lay = display ? D_layout : layout_attach; + struct layout *target = lay; + if (lay) + { + for (lay = layouts; lay->lay_next && lay->lay_next != target; lay = lay->lay_next) + ; + } + else + lay = layouts; + + if (!display) + { + layout_attach = lay; + break; + } + + if (!lay) + { + OutputMsg(0, "no layout defined"); + break; + } + if (lay == D_layout) + break; + LoadLayout(lay, &D_canvas); + Activate(-1); + } + else if (!strcmp(args[0], "attach")) + { + if (!args[1]) + { + if (!layout_attach) + OutputMsg(0, "no attach layout set"); + else if (layout_attach == &layout_last_marker) + OutputMsg(0, "will attach to last layout"); + else + OutputMsg(0, "will attach to layout %d (%s)", layout_attach->lay_number, layout_attach->lay_title); + break; + } + if (!strcmp(args[1], ":last")) + layout_attach = &layout_last_marker; + else if (!args[1][0]) + layout_attach = 0; + else + { + struct layout *lay; + lay = FindLayout(args[1]); + if (!lay) + { + OutputMsg(0, "unknown layout '%s'", args[1]); + break; + } + layout_attach = lay; + } + } + else if (!strcmp(args[0], "show")) + { + ShowLayouts(-1); + } + else if (!strcmp(args[0], "remove")) + { + struct layout *lay = display ? D_layout : layouts; + if (args[1]) + { + lay = layouts ? FindLayout(args[1]) : (struct layout *)0; + if (!lay) + { + OutputMsg(0, "unknown layout '%s'", args[1]); + break; + } + } + if (lay) + RemoveLayout(lay); + } + else if (!strcmp(args[0], "dump")) + { + if (!display) + OutputMsg(0, "Must have a display for 'layout dump'."); + else if (!LayoutDumpCanvas(&D_canvas, args[1] ? args[1] : "layout-dump")) + OutputMsg(errno, "Error dumping layout."); + else + OutputMsg(0, "Layout dumped to \"%s\"", args[1] ? args[1] : "layout-dump"); + } + else + OutputMsg(0, "unknown layout subcommand"); + break; +#ifdef DW_CHARS + case RC_CJKWIDTH: + if(ParseSwitch(act, &cjkwidth) == 0) + { + if(msgok) + OutputMsg(0, "Treat ambiguous width characters as %s width", cjkwidth ? "full" : "half"); + } + break; +#endif + default: +#ifdef HAVE_BRAILLE + /* key == -2: input from braille keybord, msgok always 0 */ + DoBrailleAction(act, key == -2 ? 0 : msgok); +#endif + break; + } + if (display != odisplay) + { + for (display = displays; display; display = display->d_next) + if (display == odisplay) + break; + } +} +#undef OutputMsg + +void +CollapseWindowlist() +/* renumber windows from 0, leaving no gaps */ +{ + int pos, moveto=0; + + for (pos = 1; pos < MAXWIN; pos++) + if (wtab[pos]) + for (; moveto < pos; moveto++) + if (!wtab[moveto]) + { + WindowChangeNumber(pos, moveto); + break; + } +} + +void +DoCommand(argv, argl) +char **argv; +int *argl; +{ + struct action act; + const char *cmd = *argv; + + act.quiet = 0; + /* For now, we actually treat both 'supress error' and 'suppress normal message' as the + * same, and ignore all messages on either flag. If we wanted to do otherwise, we would + * need to change the definition of 'OutputMsg' slightly. */ + if (*cmd == '@') /* Suppress error */ + { + act.quiet |= 0x01; + cmd++; + } + if (*cmd == '-') /* Suppress normal message */ + { + act.quiet |= 0x02; + cmd++; + } + + if ((act.nr = FindCommnr(cmd)) == RC_ILLEGAL) + { + Msg(0, "%s: unknown command '%s'", rc_name, cmd); + return; + } + act.args = argv + 1; + act.argl = argl + 1; + DoAction(&act, -1); +} + +static void +SaveAction(act, nr, args, argl) +struct action *act; +int nr; +char **args; +int *argl; +{ + register int argc = 0; + char **pp; + int *lp; + + if (args) + while (args[argc]) + argc++; + if (argc == 0) + { + act->nr = nr; + act->args = noargs; + act->argl = 0; + return; + } + if ((pp = (char **)malloc((unsigned)(argc + 1) * sizeof(char *))) == 0) + Panic(0, "%s", strnomem); + if ((lp = (int *)malloc((unsigned)(argc) * sizeof(int))) == 0) + Panic(0, "%s", strnomem); + act->nr = nr; + act->args = pp; + act->argl = lp; + while (argc--) + { + *lp = argl ? *argl++ : (int)strlen(*args); + *pp++ = SaveStrn(*args++, *lp++); + } + *pp = 0; +} + +static char ** +SaveArgs(args) +char **args; +{ + register char **ap, **pp; + register int argc = 0; + + while (args[argc]) + argc++; + if ((pp = ap = (char **)malloc((unsigned)(argc + 1) * sizeof(char **))) == 0) + Panic(0, "%s", strnomem); + while (argc--) + *pp++ = SaveStr(*args++); + *pp = 0; + return ap; +} + + +/* + * buf is split into argument vector args. + * leading whitespace is removed. + * @!| abbreviations are expanded. + * the end of buffer is recognized by '\0' or an un-escaped '#'. + * " and ' are interpreted. + * + * argc is returned. + */ +int +Parse(buf, bufl, args, argl) +char *buf, **args; +int bufl, *argl; +{ + register char *p = buf, **ap = args, *pp; + register int delim, argc; + int *lp = argl; + + debug2("Parse %d %s\n", bufl, buf); + argc = 0; + pp = buf; + delim = 0; + for (;;) + { + *lp = 0; + while (*p && (*p == ' ' || *p == '\t')) + ++p; +#ifdef PSEUDOS + if (argc == 0 && *p == '!') + { + *ap++ = "exec"; + *lp++ = 4; + p++; + argc++; + continue; + } +#endif + if (*p == '\0' || *p == '#' || *p == '\n') + { + *p = '\0'; + for (delim = 0; delim < argc; delim++) + debug1("-- %s\n", args[delim]); + args[argc] = 0; + return argc; + } + if (++argc >= MAXARGS) + { + Msg(0, "%s: too many tokens.", rc_name); + return 0; + } + *ap++ = pp; + + debug1("- new arg %s\n", p); + while (*p) + { + if (*p == delim) + delim = 0; + else if (delim != '\'' && *p == '\\' && (p[1] == 'n' || p[1] == 'r' || p[1] == 't' || p[1] == '\'' || p[1] == '"' || p[1] == '\\' || p[1] == '$' || p[1] == '#' || p[1] == '^' || (p[1] >= '0' && p[1] <= '7'))) + { + p++; + if (*p >= '0' && *p <= '7') + { + *pp = *p - '0'; + if (p[1] >= '0' && p[1] <= '7') + { + p++; + *pp = (*pp << 3) | (*p - '0'); + if (p[1] >= '0' && p[1] <= '7') + { + p++; + *pp = (*pp << 3) | (*p - '0'); + } + } + pp++; + } + else + { + switch (*p) + { + case 'n': *pp = '\n'; break; + case 'r': *pp = '\r'; break; + case 't': *pp = '\t'; break; + default: *pp = *p; break; + } + pp++; + } + } + 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] == '_')) + + { + char *ps, *pe, op, *v, xbuf[11], path[MAXPATHLEN]; + int vl; + + ps = ++p; + debug1("- var %s\n", ps); + p++; + while (*p) + { + if (*ps == '{' && *p == '}') + break; + if (*ps == ':' && *p == ':') + break; + if (*ps != '{' && *ps != ':' && (*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z') && (*p < '0' || *p > '9') && *p != '_') + break; + p++; + } + pe = p; + if (*ps == '{' || *ps == ':') + { + if (!*p) + { + Msg(0, "%s: bad variable name.", rc_name); + return 0; + } + p++; + } + op = *pe; + *pe = 0; + debug1("- var is '%s'\n", ps); + if (*ps == ':') + v = gettermcapstring(ps + 1); + else + { + if (*ps == '{') + ps++; + v = xbuf; + if (!strcmp(ps, "TERM")) + v = display ? D_termname : "unknown"; + else if (!strcmp(ps, "COLUMNS")) + sprintf(xbuf, "%d", display ? D_width : -1); + else if (!strcmp(ps, "LINES")) + sprintf(xbuf, "%d", display ? D_height : -1); + else if (!strcmp(ps, "PID")) + sprintf(xbuf, "%d", getpid()); + else if (!strcmp(ps, "PWD")) + { + if (getcwd(path, sizeof(path) - 1) == 0) + v = "?"; + else + v = path; + } + else if (!strcmp(ps, "STY")) + { + if ((v = strchr(SockName, '.'))) /* Skip the PID */ + v++; + else + v = SockName; + } + else + v = getenv(ps); + } + *pe = op; + vl = v ? strlen(v) : 0; + if (vl) + { + debug1("- sub is '%s'\n", v); + if (p - pp < vl) + { + int right = buf + bufl - (p + strlen(p) + 1); + if (right > 0) + { + bcopy(p, p + right, strlen(p) + 1); + p += right; + } + } + if (p - pp < vl) + { + Msg(0, "%s: no space left for variable expansion.", rc_name); + return 0; + } + bcopy(v, pp, vl); + pp += vl; + } + continue; + } + else if (delim != '\'' && *p == '^' && p[1]) + { + p++; + *pp++ = *p == '?' ? '\177' : *p & 0x1f; + } + else if (delim == 0 && (*p == '\'' || *p == '"')) + delim = *p; + else if (delim == 0 && (*p == ' ' || *p == '\t' || *p == '\n')) + break; + else + *pp++ = *p; + p++; + } + if (delim) + { + Msg(0, "%s: Missing %c quote.", rc_name, delim); + return 0; + } + if (*p) + p++; + *pp = 0; + debug2("- arg done, '%s' rest %s\n", ap[-1], p); + *lp++ = pp - ap[-1]; + pp++; + } +} + +void +SetEscape(u, e, me) +struct acluser *u; +int e, me; +{ + if (u) + { + u->u_Esc = e; + u->u_MetaEsc = me; + } + else + { + if (users) + { + if (DefaultEsc >= 0) + ClearAction(&ktab[DefaultEsc]); + if (DefaultMetaEsc >= 0) + ClearAction(&ktab[DefaultMetaEsc]); + } + DefaultEsc = e; + DefaultMetaEsc = me; + if (users) + { + if (DefaultEsc >= 0) + { + ClearAction(&ktab[DefaultEsc]); + ktab[DefaultEsc].nr = RC_OTHER; + } + if (DefaultMetaEsc >= 0) + { + ClearAction(&ktab[DefaultMetaEsc]); + ktab[DefaultMetaEsc].nr = RC_META; + } + } + } +} + +int +ParseSwitch(act, var) +struct action *act; +int *var; +{ + if (*act->args == 0) + { + *var ^= 1; + return 0; + } + return ParseOnOff(act, var); +} + +static int +ParseOnOff(act, var) +struct action *act; +int *var; +{ + register int num = -1; + char **args = act->args; + + if (args[1] == 0) + { + if (strcmp(args[0], "on") == 0) + num = 1; + else if (strcmp(args[0], "off") == 0) + num = 0; + } + if (num < 0) + { + Msg(0, "%s: %s: invalid argument. Give 'on' or 'off'", rc_name, comms[act->nr].name); + return -1; + } + *var = num; + return 0; +} + +int +ParseSaveStr(act, var) +struct action *act; +char **var; +{ + char **args = act->args; + if (*args == 0 || args[1]) + { + Msg(0, "%s: %s: one argument required.", rc_name, comms[act->nr].name); + return -1; + } + if (*var) + free(*var); + *var = SaveStr(*args); + return 0; +} + +int +ParseNum(act, var) +struct action *act; +int *var; +{ + int i; + char *p, **args = act->args; + + p = *args; + if (p == 0 || *p == 0 || args[1]) + { + Msg(0, "%s: %s: invalid argument. Give one argument.", + rc_name, comms[act->nr].name); + return -1; + } + i = 0; + while (*p) + { + if (*p >= '0' && *p <= '9') + i = 10 * i + (*p - '0'); + else + { + Msg(0, "%s: %s: invalid argument. Give numeric argument.", + rc_name, comms[act->nr].name); + return -1; + } + p++; + } + debug1("ParseNum got %d\n", i); + *var = i; + return 0; +} + +static int +ParseNum1000(act, var) +struct action *act; +int *var; +{ + int i; + char *p, **args = act->args; + int dig = 0; + + p = *args; + if (p == 0 || *p == 0 || args[1]) + { + Msg(0, "%s: %s: invalid argument. Give one argument.", + rc_name, comms[act->nr].name); + return -1; + } + i = 0; + while (*p) + { + if (*p >= '0' && *p <= '9') + { + if (dig < 4) + i = 10 * i + (*p - '0'); + else if (dig == 4 && *p >= '5') + i++; + if (dig) + dig++; + } + else if (*p == '.' && !dig) + dig++; + else + { + Msg(0, "%s: %s: invalid argument. Give floating point argument.", + rc_name, comms[act->nr].name); + return -1; + } + p++; + } + if (dig == 0) + i *= 1000; + else + while (dig++ < 4) + i *= 10; + if (i < 0) + i = (int)((unsigned int)~0 >> 1); + debug1("ParseNum1000 got %d\n", i); + *var = i; + return 0; +} + +static struct win * +WindowByName(s) +char *s; +{ + struct win *p; + + for (p = windows; p; p = p->w_next) + if (!strcmp(p->w_title, s)) + return p; + for (p = windows; p; p = p->w_next) + if (!strncmp(p->w_title, s, strlen(s))) + return p; + return 0; +} + +static int +WindowByNumber(str) +char *str; +{ + int i; + char *s; + + for (i = 0, s = str; *s; s++) + { + if (*s < '0' || *s > '9') + break; + i = i * 10 + (*s - '0'); + } + return *s ? -1 : i; +} + +/* + * Get window number from Name or Number string. + * Numbers are tried first, then names, a prefix match suffices. + * Be careful when assigning numeric strings as WindowTitles. + */ +int +WindowByNoN(str) +char *str; +{ + int i; + struct win *p; + + if ((i = WindowByNumber(str)) < 0 || i >= maxwin) + { + if ((p = WindowByName(str))) + return p->w_number; + return -1; + } + return i; +} + +static int +ParseWinNum(act, var) +struct action *act; +int *var; +{ + char **args = act->args; + int i = 0; + + if (*args == 0 || args[1]) + { + Msg(0, "%s: %s: one argument required.", rc_name, comms[act->nr].name); + return -1; + } + + i = WindowByNoN(*args); + if (i < 0) + { + Msg(0, "%s: %s: invalid argument. Give window number or name.", + rc_name, comms[act->nr].name); + return -1; + } + debug1("ParseWinNum got %d\n", i); + *var = i; + return 0; +} + +static int +ParseBase(act, p, var, base, bname) +struct action *act; +char *p; +int *var; +int base; +char *bname; +{ + int i = 0; + int c; + + if (*p == 0) + { + Msg(0, "%s: %s: empty argument.", rc_name, comms[act->nr].name); + return -1; + } + while ((c = *p++)) + { + if (c >= 'a' && c <= 'z') + c -= 'a' - 'A'; + if (c >= 'A' && c <= 'Z') + c -= 'A' - ('0' + 10); + c -= '0'; + if (c < 0 || c >= base) + { + Msg(0, "%s: %s: argument is not %s.", rc_name, comms[act->nr].name, bname); + return -1; + } + i = base * i + c; + } + debug1("ParseBase got %d\n", i); + *var = i; + return 0; +} + +static int +IsNum(s, base) +register char *s; +register int base; +{ + for (base += '0'; *s; ++s) + if (*s < '0' || *s > base) + return 0; + return 1; +} + +int +IsNumColon(s, base, p, psize) +int base, psize; +char *s, *p; +{ + char *q; + if ((q = rindex(s, ':')) != 0) + { + strncpy(p, q + 1, psize - 1); + p[psize - 1] = '\0'; + *q = '\0'; + } + else + *p = '\0'; + return IsNum(s, base); +} + +void +SwitchWindow(n) +int n; +{ + struct win *p; + + debug1("SwitchWindow %d\n", n); + if (n < 0 || n >= maxwin) + { + ShowWindows(-1); + return; + } + if ((p = wtab[n]) == 0) + { + ShowWindows(n); + return; + } + if (display == 0) + { + fore = p; + return; + } + if (p == D_fore) + { + Msg(0, "This IS window %d (%s).", n, p->w_title); + return; + } +#ifdef MULTIUSER + if (AclCheckPermWin(D_user, ACL_READ, p)) + { + Msg(0, "Access to window %d denied.", p->w_number); + return; + } +#endif + SetForeWindow(p); + Activate(fore->w_norefresh); +} + +/* + * SetForeWindow changes the window in the input focus of the display. + * Puts window wi in canvas display->d_forecv. + */ +void +SetForeWindow(wi) +struct win *wi; +{ + struct win *p; + if (display == 0) + { + fore = wi; + return; + } + p = Layer2Window(D_forecv->c_layer); + SetCanvasWindow(D_forecv, wi); + if (p) + WindowChanged(p, 'u'); + if (wi) + WindowChanged(wi, 'u'); + flayer = D_forecv->c_layer; + /* Activate called afterwards, so no RefreshHStatus needed */ +} + + +/*****************************************************************/ + +/* + * Activate - make fore window active + * norefresh = -1 forces a refresh, disregard all_norefresh then. + */ +void +Activate(norefresh) +int norefresh; +{ + debug1("Activate(%d)\n", norefresh); + if (display == 0) + return; + if (D_status) + { + Msg(0, "%s", ""); /* wait till mintime (keep gcc quiet) */ + RemoveStatus(); + } + + if (MayResizeLayer(D_forecv->c_layer)) + ResizeLayer(D_forecv->c_layer, D_forecv->c_xe - D_forecv->c_xs + 1, D_forecv->c_ye - D_forecv->c_ys + 1, display); + + fore = D_fore; + if (fore) + { + /* XXX ? */ + if (fore->w_monitor != MON_OFF) + fore->w_monitor = MON_ON; + fore->w_bell = BELL_ON; + WindowChanged(fore, 'f'); + +#if 0 + if (ResizeDisplay(fore->w_width, fore->w_height)) + { + debug2("Cannot resize from (%d,%d)", D_width, D_height); + debug2(" to (%d,%d) -> resize window\n", fore->w_width, fore->w_height); + DoResize(D_width, D_height); + } +#endif + } + Redisplay(norefresh + all_norefresh); +} + + +static int +NextWindow() +{ + register struct win **pp; + int n = fore ? fore->w_number : maxwin; + struct win *group = fore ? fore->w_group : 0; + + for (pp = fore ? wtab + n + 1 : wtab; pp != wtab + n; pp++) + { + if (pp == wtab + maxwin) + pp = wtab; + if (*pp) + { + if (!fore || group == (*pp)->w_group) + break; + } + } + if (pp == wtab + n) + return -1; + return pp - wtab; +} + +static int +PreviousWindow() +{ + register struct win **pp; + int n = fore ? fore->w_number : -1; + struct win *group = fore ? fore->w_group : 0; + + for (pp = wtab + n - 1; pp != wtab + n; pp--) + { + if (pp == wtab - 1) + pp = wtab + maxwin - 1; + if (*pp) + { + if (!fore || group == (*pp)->w_group) + break; + } + } + if (pp == wtab + n) + return -1; + return pp - wtab; +} + +static int +MoreWindows() +{ + char *m = "No other window."; + if (windows && (fore == 0 || windows->w_next)) + return 1; + if (fore == 0) + { + Msg(0, "No window available"); + return 0; + } + Msg(0, m, fore->w_number); /* other arg for nethack */ + return 0; +} + +void +KillWindow(wi) +struct win *wi; +{ + struct win **pp, *p; + struct canvas *cv; + int gotone; + struct layout *lay; + + /* + * Remove window from linked list. + */ + for (pp = &windows; (p = *pp); pp = &p->w_next) + if (p == wi) + break; + ASSERT(p); + *pp = p->w_next; + wi->w_inlen = 0; + wtab[wi->w_number] = 0; + + if (windows == 0) + { + FreeWindow(wi); + Finit(0); + } + + /* + * switch to different window on all canvases + */ + for (display = displays; display; display = display->d_next) + { + gotone = 0; + for (cv = D_cvlist; cv; cv = cv->c_next) + { + if (Layer2Window(cv->c_layer) != wi) + continue; + /* switch to other window */ + SetCanvasWindow(cv, FindNiceWindow(D_other, 0)); + gotone = 1; + } + if (gotone) + { +#ifdef ZMODEM + if (wi->w_zdisplay == display) + { + D_blocked = 0; + D_readev.condpos = D_readev.condneg = 0; + } +#endif + Activate(-1); + } + } + + /* do the same for the layouts */ + for (lay = layouts; lay; lay = lay->lay_next) + UpdateLayoutCanvas(&lay->lay_canvas, wi); + + FreeWindow(wi); + WindowChanged((struct win *)0, 'w'); + WindowChanged((struct win *)0, 'W'); + WindowChanged((struct win *)0, 0); +} + +static void +LogToggle(on) +int on; +{ + char buf[1024]; + + if ((fore->w_log != 0) == on) + { + if (display && !*rc_name) + Msg(0, "You are %s logging.", on ? "already" : "not"); + return; + } + if (fore->w_log != 0) + { + Msg(0, "Logfile \"%s\" closed.", fore->w_log->name); + logfclose(fore->w_log); + fore->w_log = 0; + WindowChanged(fore, 'f'); + return; + } + if (DoStartLog(fore, buf, sizeof(buf))) + { + Msg(errno, "Error opening logfile \"%s\"", buf); + return; + } + if (ftell(fore->w_log->fp) == 0) + Msg(0, "Creating logfile \"%s\".", fore->w_log->name); + else + Msg(0, "Appending to logfile \"%s\".", fore->w_log->name); + WindowChanged(fore, 'f'); +} + +char * +AddWindows(buf, len, flags, where) +char *buf; +int len; +int flags; +int where; +{ + register char *s, *ss; + register struct win **pp, *p; + register char *cmd; + int l; + + s = ss = buf; + if ((flags & 8) && where < 0) + { + *s = 0; + return ss; + } + for (pp = ((flags & 4) && where >= 0) ? wtab + where + 1: wtab; pp < wtab + maxwin; pp++) + { + int rend = -1; + if (pp - wtab == where && ss == buf) + ss = s; + if ((p = *pp) == 0) + continue; + if ((flags & 1) && display && p == D_fore) + continue; + if (display && D_fore && D_fore->w_group != p->w_group) + continue; + + cmd = p->w_title; + l = strlen(cmd); + if (l > 20) + l = 20; + if (s - buf + l > len - 24) + break; + if (s > buf || (flags & 4)) + { + *s++ = ' '; + *s++ = ' '; + } + if (p->w_number == where) + { + ss = s; + if (flags & 8) + break; + } + if (!(flags & 4) || where < 0 || ((flags & 4) && where < p->w_number)) + { + if (p->w_monitor == MON_DONE && renditions[REND_MONITOR] != -1) + rend = renditions[REND_MONITOR]; + else if ((p->w_bell == BELL_DONE || p->w_bell == BELL_FOUND) && renditions[REND_BELL] != -1) + rend = renditions[REND_BELL]; + else if ((p->w_silence == SILENCE_FOUND || p->w_silence == SILENCE_DONE) && renditions[REND_SILENCE] != -1) + rend = renditions[REND_SILENCE]; + } + if (rend != -1) + AddWinMsgRend(s, rend); + sprintf(s, "%d", p->w_number); + s += strlen(s); + if (display && p == D_fore) + *s++ = '*'; + if (!(flags & 2)) + { + if (display && p == D_other) + *s++ = '-'; + s = AddWindowFlags(s, len, p); + } + *s++ = ' '; + strncpy(s, cmd, l); + s += l; + if (rend != -1) + AddWinMsgRend(s, -1); + } + *s = 0; + return ss; +} + +char * +AddWindowFlags(buf, len, p) +char *buf; +int len; +struct win *p; +{ + char *s = buf; + if (p == 0 || len < 12) + { + *s = 0; + return s; + } +#if 0 + if (display && p == D_fore) + *s++ = '*'; + if (display && p == D_other) + *s++ = '-'; +#endif + if (p->w_layer.l_cvlist && p->w_layer.l_cvlist->c_lnext) + *s++ = '&'; + if (p->w_monitor == MON_DONE +#ifdef MULTIUSER + && display && (ACLBYTE(p->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id)) +#endif + ) + *s++ = '@'; + if (p->w_bell == BELL_DONE) + *s++ = '!'; +#ifdef UTMPOK + if (p->w_slot != (slot_t) 0 && p->w_slot != (slot_t) -1) + *s++ = '$'; +#endif + if (p->w_log != 0) + { + strcpy(s, "(L)"); + s += 3; + } + if (p->w_ptyfd < 0 && p->w_type != W_TYPE_GROUP) + *s++ = 'Z'; + *s = 0; + return s; +} + +char * +AddOtherUsers(buf, len, p) +char *buf; +int len; +struct win *p; +{ + struct display *d, *olddisplay = display; + struct canvas *cv; + char *s; + int l; + + s = buf; + for (display = displays; display; display = display->d_next) + { + if (olddisplay && D_user == olddisplay->d_user) + continue; + for (cv = D_cvlist; cv; cv = cv->c_next) + if (Layer2Window(cv->c_layer) == p) + break; + if (!cv) + continue; + for (d = displays; d && d != display; d = d->d_next) + if (D_user == d->d_user) + break; + if (d && d != display) + continue; + if (len > 1 && s != buf) + { + *s++ = ','; + len--; + } + l = strlen(D_user->u_name); + if (l + 1 > len) + break; + strcpy(s, D_user->u_name); + s += l; + len -= l; + } + *s = 0; + display = olddisplay; + return s; +} + +void +ShowWindows(where) +int where; +{ + char buf[1024]; + char *s, *ss; + + if (display && where == -1 && D_fore) + where = D_fore->w_number; + ss = AddWindows(buf, sizeof(buf), 0, where); + s = buf + strlen(buf); + if (display && ss - buf > D_width / 2) + { + ss -= D_width / 2; + if (s - ss < D_width) + { + ss = s - D_width; + if (ss < buf) + ss = buf; + } + } + else + ss = buf; + Msg(0, "%s", ss); +} + +/* +* String Escape based windows listing +* mls: currently does a Msg() call for each(!) window, dunno why +*/ +static void +ShowWindowsX(str) +char *str; +{ + int i; + debug1("ShowWindowsX: string [%s]", str); + for (i = 0; i < maxwin ; i++) { + if (!wtab[i]) + continue; + Msg(0, "%s", MakeWinMsg(str, wtab[i], '%')); + } +} + + +static void +ShowInfo() +{ + char buf[512], *p; + register struct win *wp = fore; + register int i; + + if (wp == 0) + { + Msg(0, "(%d,%d)/(%d,%d) no window", D_x + 1, D_y + 1, D_width, D_height); + return; + } + p = buf; + if (buf < (p += GetAnsiStatus(wp, p))) + *p++ = ' '; + sprintf(p, "(%d,%d)/(%d,%d)", + wp->w_x + 1, wp->w_y + 1, wp->w_width, wp->w_height); +#ifdef COPY_PASTE + sprintf(p += strlen(p), "+%d", wp->w_histheight); +#endif + sprintf(p += strlen(p), " %c%sflow", + (wp->w_flow & FLOW_NOW) ? '+' : '-', + (wp->w_flow & FLOW_AUTOFLAG) ? "" : + ((wp->w_flow & FLOW_AUTO) ? "(+)" : "(-)")); + if (!wp->w_wrap) sprintf(p += strlen(p), " -wrap"); + if (wp->w_insert) sprintf(p += strlen(p), " ins"); + if (wp->w_origin) sprintf(p += strlen(p), " org"); + if (wp->w_keypad) sprintf(p += strlen(p), " app"); + if (wp->w_log) sprintf(p += strlen(p), " log"); + if (wp->w_monitor != MON_OFF +#ifdef MULTIUSER + && (ACLBYTE(wp->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id)) +#endif + ) + sprintf(p += strlen(p), " mon"); + if (wp->w_mouse) sprintf(p += strlen(p), " mouse"); +#ifdef COLOR + if (wp->w_bce) sprintf(p += strlen(p), " bce"); +#endif + if (!wp->w_c1) sprintf(p += strlen(p), " -c1"); + if (wp->w_norefresh) sprintf(p += strlen(p), " nored"); + + p += strlen(p); +#ifdef FONT +# ifdef ENCODINGS + if (wp->w_encoding && (display == 0 || D_encoding != wp->w_encoding || EncodingDefFont(wp->w_encoding) <= 0)) + { + *p++ = ' '; + strcpy(p, EncodingName(wp->w_encoding)); + p += strlen(p); + } +# ifdef UTF8 + if (wp->w_encoding != UTF8) +# endif +# endif + if (display && (D_CC0 || (D_CS0 && *D_CS0))) + { + if (wp->w_gr == 2) + { + sprintf(p, " G%c", wp->w_Charset + '0'); + if (wp->w_FontE >= ' ') + p[3] = wp->w_FontE; + else + { + p[3] = '^'; + p[4] = wp->w_FontE ^ 0x40; + p++; + } + p[4] = '['; + p++; + } + else if (wp->w_gr) + sprintf(p++, " G%c%c[", wp->w_Charset + '0', wp->w_CharsetR + '0'); + else + sprintf(p, " G%c[", wp->w_Charset + '0'); + p += 4; + for (i = 0; i < 4; i++) + { + if (wp->w_charsets[i] == ASCII) + *p++ = 'B'; + else if (wp->w_charsets[i] >= ' ') + *p++ = wp->w_charsets[i]; + else + { + *p++ = '^'; + *p++ = wp->w_charsets[i] ^ 0x40; + } + } + *p++ = ']'; + *p = 0; + } +#endif + + if (wp->w_type == W_TYPE_PLAIN) + { + /* add info about modem control lines */ + *p++ = ' '; + TtyGetModemStatus(wp->w_ptyfd, p); + } +#ifdef BUILTIN_TELNET + else if (wp->w_type == W_TYPE_TELNET) + { + *p++ = ' '; + TelStatus(wp, p, sizeof(buf) - 1 - (p - buf)); + } +#endif + Msg(0, "%s %d(%s)", buf, wp->w_number, wp->w_title); +} + +static void +ShowDInfo() +{ + char buf[512], *p; + if (display == 0) + return; + p = buf; + sprintf(p, "(%d,%d)", D_width, D_height), + p += strlen(p); +#ifdef ENCODINGS + if (D_encoding) + { + *p++ = ' '; + strcpy(p, EncodingName(D_encoding)); + p += strlen(p); + } +#endif + if (D_CXT) + { + strcpy(p, " xterm"); + p += strlen(p); + } +#ifdef COLOR + if (D_hascolor) + { + strcpy(p, " color"); + p += strlen(p); + } +#endif +#ifdef FONT + if (D_CG0) + { + strcpy(p, " iso2022"); + p += strlen(p); + } + else if (D_CS0 && *D_CS0) + { + strcpy(p, " altchar"); + p += strlen(p); + } +#endif + Msg(0, "%s", buf); +} + +static void +AKAfin(buf, len, data) +char *buf; +int len; +char *data; /* dummy */ +{ + ASSERT(display); + if (len && fore) + ChangeAKA(fore, buf, strlen(buf)); + + enter_window_name_mode = 0; +} + +static void +InputAKA() +{ + char *s, *ss; + int n; + + if (enter_window_name_mode == 1) return; + + enter_window_name_mode = 1; + + Input("Set window's title to: ", sizeof(fore->w_akabuf) - 1, INP_COOKED, AKAfin, NULL, 0); + s = fore->w_title; + if (!s) + return; + for (; *s; s++) + { + if ((*(unsigned char *)s & 0x7f) < 0x20 || *s == 0x7f) + continue; + ss = s; + n = 1; + LayProcess(&ss, &n); + } +} + +static void +Colonfin(buf, len, data) +char *buf; +int len; +char *data; /* dummy */ +{ + char mbuf[256]; + + RemoveStatus(); + if (buf[len] == '\t') + { + int m, x; + int l = 0, r = RC_LAST; + int showmessage = 0; + char *s = buf; + + while (*s && s - buf < len) + if (*s++ == ' ') + return; + + /* Showing a message when there's no hardstatus or caption cancels the input */ + if (display && + (captionalways || D_has_hstatus == HSTATUS_LASTLINE || (D_canvas.c_slperp && D_canvas.c_slperp->c_slnext))) + showmessage = 1; + + while (l <= r) + { + m = (l + r) / 2; + x = strncmp(buf, comms[m].name, len); + if (x > 0) + l = m + 1; + else if (x < 0) + r = m - 1; + else + { + s = mbuf; + for (l = m - 1; l >= 0 && strncmp(buf, comms[l].name, len) == 0; l--) + ; + for (m = ++l; m <= r && strncmp(buf, comms[m].name, len) == 0 && s - mbuf < sizeof(mbuf); m++) + s += snprintf(s, sizeof(mbuf) - (s - mbuf), " %s", comms[m].name); + if (l < m - 1) + { + if (showmessage) + Msg(0, "Possible commands:%s", mbuf); + } + else + { + s = mbuf; + len = snprintf(mbuf, sizeof(mbuf), "%s \t", comms[l].name + len); + if (len > 0 && len < sizeof(mbuf)) + LayProcess(&s, &len); + } + break; + } + } + if (l > r && showmessage) + Msg(0, "No commands matching '%*s'", len, buf); + return; + } + + if (!len || buf[len]) + return; + + len = strlen(buf) + 1; + if (len > (int)sizeof(mbuf)) + RcLine(buf, len); + else + { + bcopy(buf, mbuf, len); + RcLine(mbuf, sizeof mbuf); + } +} + +static void +SelectFin(buf, len, data) +char *buf; +int len; +char *data; /* dummy */ +{ + int n; + + if (!len || !display) + return; + if (len == 1 && *buf == '-') + { + SetForeWindow((struct win *)0); + Activate(0); + return; + } + if ((n = WindowByNoN(buf)) < 0) + return; + SwitchWindow(n); +} + +static void +SelectLayoutFin(buf, len, data) +char *buf; +int len; +char *data; /* dummy */ +{ + struct layout *lay; + + if (!len || !display) + return; + if (len == 1 && *buf == '-') + { + LoadLayout((struct layout *)0, (struct canvas *)0); + Activate(0); + return; + } + lay = FindLayout(buf); + if (!lay) + Msg(0, "No such layout\n"); + else if (lay == D_layout) + Msg(0, "This IS layout %d (%s).\n", lay->lay_number, lay->lay_title); + else + { + LoadLayout(lay, &D_canvas); + Activate(0); + } +} + + +static void +InputSelect() +{ + Input("Switch to window: ", 20, INP_COOKED, SelectFin, NULL, 0); +} + +static char setenv_var[31]; + + +static void +SetenvFin1(buf, len, data) +char *buf; +int len; +char *data; /* dummy */ +{ + if (!len || !display) + return; + InputSetenv(buf); +} + +static void +SetenvFin2(buf, len, data) +char *buf; +int len; +char *data; /* dummy */ +{ + if (!len || !display) + return; + debug2("SetenvFin2: setenv '%s' '%s'\n", setenv_var, buf); + xsetenv(setenv_var, buf); + MakeNewEnv(); +} + +static void +InputSetenv(arg) +char *arg; +{ + static char setenv_buf[50 + sizeof(setenv_var)]; /* need to be static here, cannot be freed */ + + if (arg) + { + strncpy(setenv_var, arg, sizeof(setenv_var) - 1); + sprintf(setenv_buf, "Enter value for %s: ", setenv_var); + Input(setenv_buf, 30, INP_COOKED, SetenvFin2, NULL, 0); + } + else + Input("Setenv: Enter variable name: ", 30, INP_COOKED, SetenvFin1, NULL, 0); +} + +/* + * the following options are understood by this parser: + * -f, -f0, -f1, -fy, -fa + * -t title, -T terminal-type, -h height-of-scrollback, + * -ln, -l0, -ly, -l1, -l + * -a, -M, -L + */ +void +DoScreen(fn, av) +char *fn, **av; +{ + struct NewWindow nwin; + register int num; + char buf[20]; + + nwin = nwin_undef; + while (av && *av && av[0][0] == '-') + { + if (av[0][1] == '-') + { + av++; + break; + } + switch (av[0][1]) + { + case 'f': + switch (av[0][2]) + { + case 'n': + case '0': + nwin.flowflag = FLOW_NOW * 0; + break; + case 'y': + case '1': + case '\0': + nwin.flowflag = FLOW_NOW * 1; + break; + case 'a': + nwin.flowflag = FLOW_AUTOFLAG; + break; + default: + break; + } + break; + case 't': /* no more -k */ + if (av[0][2]) + nwin.aka = &av[0][2]; + else if (*++av) + nwin.aka = *av; + else + --av; + break; + case 'T': + if (av[0][2]) + nwin.term = &av[0][2]; + else if (*++av) + nwin.term = *av; + else + --av; + break; + case 'h': + if (av[0][2]) + nwin.histheight = atoi(av[0] + 2); + else if (*++av) + nwin.histheight = atoi(*av); + else + --av; + break; +#ifdef LOGOUTOK + case 'l': + switch (av[0][2]) + { + case 'n': + case '0': + nwin.lflag = 0; + break; + case 'y': + case '1': + case '\0': + nwin.lflag = 1; + break; + case 'a': + nwin.lflag = 3; + break; + default: + break; + } + break; +#endif + case 'a': + nwin.aflag = 1; + break; + case 'M': + nwin.monitor = MON_ON; + break; + case 'L': + nwin.Lflag = 1; + break; + default: + Msg(0, "%s: screen: invalid option -%c.", fn, av[0][1]); + break; + } + ++av; + } + if (av && *av && IsNumColon(*av, 10, buf, sizeof(buf))) + { + if (*buf != '\0') + nwin.aka = buf; + num = atoi(*av); + if (num < 0 || (maxwin && num > maxwin - 1) || (!maxwin && num > MAXWIN - 1)) + { + Msg(0, "%s: illegal screen number %d.", fn, num); + num = 0; + } + nwin.StartAt = num; + ++av; + } + if (av && *av) + { + nwin.args = av; + if (!nwin.aka) + nwin.aka = Filename(*av); + } + MakeWindow(&nwin); +} + +#ifdef COPY_PASTE +/* + * CompileKeys must be called before Markroutine is first used. + * to initialise the keys with defaults, call CompileKeys(NULL, mark_key_tab); + * + * s is an ascii string in a termcap-like syntax. It looks like + * "j=u:k=d:l=r:h=l: =.:" and so on... + * this example rebinds the cursormovement to the keys u (up), d (down), + * l (left), r (right). placing a mark will now be done with ".". + */ +int +CompileKeys(s, sl, array) +char *s; +int sl; +unsigned char *array; +{ + int i; + unsigned char key, value; + + if (sl == 0) + { + for (i = 0; i < 256; i++) + array[i] = i; + return 0; + } + debug1("CompileKeys: '%s'\n", s); + while (sl) + { + key = *(unsigned char *)s++; + if (*s != '=' || sl < 3) + return -1; + sl--; + do + { + s++; + sl -= 2; + value = *(unsigned char *)s++; + array[value] = key; + } + while (*s == '=' && sl >= 2); + if (sl == 0) + break; + if (*s++ != ':') + return -1; + sl--; + } + return 0; +} +#endif /* COPY_PASTE */ + +/* + * Asynchronous input functions + */ + +#if defined(DETACH) && defined(POW_DETACH) +static void +pow_detach_fn(buf, len, data) +char *buf; +int len; +char *data; /* dummy */ +{ + debug("pow_detach_fn called\n"); + if (len) + { + memset(buf, 0, len); + return; + } + if (ktab[(int)(unsigned char)*buf].nr != RC_POW_DETACH) + { + if (display) + write(D_userfd, "\007", 1); + Msg(0, "Detach aborted."); + } + else + Detach(D_POWER); +} +#endif /* POW_DETACH */ + +#ifdef COPY_PASTE +static void +copy_reg_fn(buf, len, data) +char *buf; +int len; +char *data; /* dummy */ +{ + struct plop *pp = plop_tab + (int)(unsigned char)*buf; + + if (len) + { + memset(buf, 0, len); + return; + } + if (pp->buf) + free(pp->buf); + pp->buf = 0; + pp->len = 0; + if (D_user->u_plop.len) + { + if ((pp->buf = (char *)malloc(D_user->u_plop.len)) == NULL) + { + Msg(0, "%s", strnomem); + return; + } + bcopy(D_user->u_plop.buf, pp->buf, D_user->u_plop.len); + } + pp->len = D_user->u_plop.len; +#ifdef ENCODINGS + pp->enc = D_user->u_plop.enc; +#endif + Msg(0, "Copied %d characters into register %c", D_user->u_plop.len, *buf); +} + +static void +ins_reg_fn(buf, len, data) +char *buf; +int len; +char *data; /* dummy */ +{ + struct plop *pp = plop_tab + (int)(unsigned char)*buf; + + if (len) + { + memset(buf, 0, len); + return; + } + if (!fore) + return; /* Input() should not call us w/o fore, but you never know... */ + if (*buf == '.') + Msg(0, "ins_reg_fn: Warning: pasting real register '.'!"); + if (pp->buf) + { + MakePaster(&fore->w_paster, pp->buf, pp->len, 0); + return; + } + Msg(0, "Empty register."); +} +#endif /* COPY_PASTE */ + +static void +process_fn(buf, len, data) +char *buf; +int len; +char *data; /* dummy */ +{ + struct plop *pp = plop_tab + (int)(unsigned char)*buf; + + if (len) + { + memset(buf, 0, len); + return; + } + if (pp->buf) + { + ProcessInput(pp->buf, pp->len); + return; + } + Msg(0, "Empty register."); +} + +static void +confirm_fn(buf, len, data) +char *buf; +int len; +char *data; +{ + struct action act; + + if (len || (*buf != 'y' && *buf != 'Y')) + { + memset(buf, 0, len); + return; + } + act.nr = *(int *)data; + act.args = noargs; + act.argl = 0; + act.quiet = 0; + DoAction(&act, -1); +} + +#ifdef MULTIUSER +struct inputsu +{ + struct acluser **up; + char name[24]; + char pw1[130]; /* FreeBSD crypts to 128 bytes */ + char pw2[130]; +}; + +static void +su_fin(buf, len, data) +char *buf; +int len; +char *data; +{ + struct inputsu *i = (struct inputsu *)data; + char *p; + int l; + + if (!*i->name) + { p = i->name; l = sizeof(i->name) - 1; } + else if (!*i->pw1) + { strcpy(p = i->pw1, "\377"); l = sizeof(i->pw1) - 1; } + else + { strcpy(p = i->pw2, "\377"); l = sizeof(i->pw2) - 1; } + if (buf && len) + strncpy(p, buf, 1 + ((l < len) ? l : len)); + if (!*i->name) + Input("Screen User: ", sizeof(i->name) - 1, INP_COOKED, su_fin, (char *)i, 0); + else if (!*i->pw1) + Input("User's UNIX Password: ", sizeof(i->pw1)-1, INP_COOKED|INP_NOECHO, su_fin, (char *)i, 0); + else if (!*i->pw2) + Input("User's Screen Password: ", sizeof(i->pw2)-1, INP_COOKED|INP_NOECHO, su_fin, (char *)i, 0); + else + { + if ((p = DoSu(i->up, i->name, i->pw2, i->pw1))) + Msg(0, "%s", p); + free((char *)i); + } +} + +static int +InputSu(w, up, name) +struct win *w; +struct acluser **up; +char *name; +{ + struct inputsu *i; + + if (!(i = (struct inputsu *)calloc(1, sizeof(struct inputsu)))) + return -1; + + i->up = up; + if (name && *name) + su_fin(name, (int)strlen(name), (char *)i); /* can also initialise stuff */ + else + su_fin((char *)0, 0, (char *)i); + return 0; +} +#endif /* MULTIUSER */ + +#ifdef PASSWORD + +static void +pass1(buf, len, data) +char *buf; +int len; +char *data; +{ + struct acluser *u = (struct acluser *)data; + + if (!*buf) + return; + ASSERT(u); + if (u->u_password != NullStr) + free((char *)u->u_password); + u->u_password = SaveStr(buf); + bzero(buf, strlen(buf)); + Input("Retype new password:", 100, INP_NOECHO, pass2, data, 0); +} + +static void +pass2(buf, len, data) +char *buf; +int len; +char *data; +{ + int st; + char salt[3]; + struct acluser *u = (struct acluser *)data; + + ASSERT(u); + if (!buf || strcmp(u->u_password, buf)) + { + Msg(0, "[ Passwords don't match - checking turned off ]"); + if (u->u_password != NullStr) + { + bzero(u->u_password, strlen(u->u_password)); + free((char *)u->u_password); + } + u->u_password = NullStr; + } + else if (u->u_password[0] == '\0') + { + Msg(0, "[ No password - no secure ]"); + if (buf) + bzero(buf, strlen(buf)); + } + + if (u->u_password != NullStr) + { + for (st = 0; st < 2; st++) + salt[st] = 'A' + (int)((time(0) >> 6 * st) % 26); + salt[2] = 0; + buf = crypt(u->u_password, salt); + bzero(u->u_password, strlen(u->u_password)); + free((char *)u->u_password); + if (!buf) + { + Msg(0, "[ crypt() error - no secure ]"); + u->u_password = NullStr; + return; + } + u->u_password = SaveStr(buf); + bzero(buf, strlen(buf)); +#ifdef COPY_PASTE + if (u->u_plop.buf) + UserFreeCopyBuffer(u); + u->u_plop.len = strlen(u->u_password); +# ifdef ENCODINGS + u->u_plop.enc = 0; +#endif + if (!(u->u_plop.buf = SaveStr(u->u_password))) + { + Msg(0, "%s", strnomem); + D_user->u_plop.len = 0; + } + else + Msg(0, "[ Password moved into copybuffer ]"); +#else /* COPY_PASTE */ + Msg(0, "[ Crypted password is \"%s\" ]", u->u_password); +#endif /* COPY_PASTE */ + } +} +#endif /* PASSWORD */ + +static int +digraph_find(buf) +const char *buf; +{ + int i; + for (i = 0; i < MAX_DIGRAPH && digraphs[i].d[0]; i++) + if ((digraphs[i].d[0] == (unsigned char)buf[0] && digraphs[i].d[1] == (unsigned char)buf[1]) || + (digraphs[i].d[0] == (unsigned char)buf[1] && digraphs[i].d[1] == (unsigned char)buf[0])) + break; + return i; +} + +static void +digraph_fn(buf, len, data) +char *buf; +int len; +char *data; /* dummy */ +{ + int ch, i, x; + + ch = buf[len]; + if (ch) + { + buf[len + 1] = ch; /* so we can restore it later */ + if (ch < ' ' || ch == '\177') + return; + if (len >= 1 && ((*buf == 'U' && buf[1] == '+') || (*buf == '0' && (buf[1] == 'x' || buf[1] == 'X')))) + { + if (len == 1) + return; + if ((ch < '0' || ch > '9') && (ch < 'a' || ch > 'f') && (ch < 'A' || ch > 'F')) + { + buf[len] = '\034'; /* ^] is ignored by Input() */ + return; + } + if (len == (*buf == 'U' ? 5 : 3)) + buf[len] = '\n'; + return; + } + if (len && *buf == '0') + { + if (ch < '0' || ch > '7') + { + buf[len] = '\034'; /* ^] is ignored by Input() */ + return; + } + if (len == 3) + buf[len] = '\n'; + return; + } + if (len == 1) + buf[len] = '\n'; + return; + } + if (len < 1) + return; + if (buf[len + 1]) + { + buf[len] = buf[len + 1]; /* stored above */ + len++; + } + if (len < 2) + return; + if (!parse_input_int(buf, len, &x)) + { + i = digraph_find(buf); + if ((x = digraphs[i].value) <= 0) + { + Msg(0, "Unknown digraph"); + return; + } + } + i = 1; + *buf = x; +#ifdef UTF8 + if (flayer->l_encoding == UTF8) + i = ToUtf8(buf, x); /* buf is big enough for all UTF-8 codes */ +#endif + while(i) + LayProcess(&buf, &i); +} + +#ifdef MAPKEYS +int +StuffKey(i) +int i; +{ + struct action *act; + int discard = 0; + int keyno = i; + + debug1("StuffKey #%d", i); +#ifdef DEBUG + if (i < KMAP_KEYS) + debug1(" - %s", term[i + T_CAPS].tcname); +#endif + + if (i < KMAP_KEYS && D_ESCseen) + { + struct action *act = &D_ESCseen[i + 256]; + if (act->nr != RC_ILLEGAL) + { + D_ESCseen = 0; + WindowChanged(fore, 'E'); + DoAction(act, i + 256); + return 0; + } + discard = 1; + } + + if (i >= T_CURSOR - T_CAPS && i < T_KEYPAD - T_CAPS && D_cursorkeys) + i += T_OCAPS - T_CURSOR; + else if (i >= T_KEYPAD - T_CAPS && i < T_OCAPS - T_CAPS && D_keypad) + i += T_OCAPS - T_CURSOR; + debug1(" - action %d\n", i); + flayer = D_forecv->c_layer; + fore = D_fore; + act = 0; +#ifdef COPY_PASTE + if (flayer && flayer->l_mode == 1) + act = i < KMAP_KEYS+KMAP_AKEYS ? &mmtab[i] : &kmap_exts[i - (KMAP_KEYS+KMAP_AKEYS)].mm; +#endif + if ((!act || act->nr == RC_ILLEGAL) && !D_mapdefault) + act = i < KMAP_KEYS+KMAP_AKEYS ? &umtab[i] : &kmap_exts[i - (KMAP_KEYS+KMAP_AKEYS)].um; + if (!act || act->nr == RC_ILLEGAL) + act = i < KMAP_KEYS+KMAP_AKEYS ? &dmtab[i] : &kmap_exts[i - (KMAP_KEYS+KMAP_AKEYS)].dm; + + if (discard && (!act || act->nr != RC_COMMAND)) + { + /* if the input was just a single byte we let it through */ + if (D_tcs[keyno + T_CAPS].str && strlen(D_tcs[keyno + T_CAPS].str) == 1) + return -1; + if (D_ESCseen) + { + D_ESCseen = 0; + WindowChanged(fore, 'E'); + } + return 0; + } + D_mapdefault = 0; + + if (act == 0 || act->nr == RC_ILLEGAL) + return -1; + DoAction(act, 0); + return 0; +} +#endif + + +static int +IsOnDisplay(wi) +struct win *wi; +{ + struct canvas *cv; + ASSERT(display); + for (cv = D_cvlist; cv; cv = cv->c_next) + if (Layer2Window(cv->c_layer) == wi) + return 1; + return 0; +} + +struct win * +FindNiceWindow(wi, presel) +struct win *wi; +char *presel; +{ + int i; + + debug2("FindNiceWindow %d %s\n", wi ? wi->w_number : -1 , presel ? presel : "NULL"); + if (presel) + { + i = WindowByNoN(presel); + if (i >= 0) + wi = wtab[i]; + } + if (!display) + return wi; +#ifdef MULTIUSER + if (wi && AclCheckPermWin(D_user, ACL_READ, wi)) + wi = 0; +#endif + if (!wi || (IsOnDisplay(wi) && !presel)) + { + /* try to get another window */ + wi = 0; +#ifdef MULTIUSER + for (wi = windows; wi; wi = wi->w_next) + if (!wi->w_layer.l_cvlist && !AclCheckPermWin(D_user, ACL_WRITE, wi)) + break; + if (!wi) + for (wi = windows; wi; wi = wi->w_next) + if (wi->w_layer.l_cvlist && !IsOnDisplay(wi) && !AclCheckPermWin(D_user, ACL_WRITE, wi)) + break; + if (!wi) + for (wi = windows; wi; wi = wi->w_next) + if (!wi->w_layer.l_cvlist && !AclCheckPermWin(D_user, ACL_READ, wi)) + break; + if (!wi) + for (wi = windows; wi; wi = wi->w_next) + if (wi->w_layer.l_cvlist && !IsOnDisplay(wi) && !AclCheckPermWin(D_user, ACL_READ, wi)) + break; +#endif + if (!wi) + for (wi = windows; wi; wi = wi->w_next) + if (!wi->w_layer.l_cvlist) + break; + if (!wi) + for (wi = windows; wi; wi = wi->w_next) + if (wi->w_layer.l_cvlist && !IsOnDisplay(wi)) + break; + } +#ifdef MULTIUSER + if (wi && AclCheckPermWin(D_user, ACL_READ, wi)) + wi = 0; +#endif + return wi; +} + +#if 0 + +/* sorted list of all commands */ +static struct comm **commtab; +static int ncommtab; + +void +AddComms(cos, hand) +struct comm *cos; +void (*hand) __P((struct comm *, char **, int)); +{ + int n, i, j, r; + for (n = 0; cos[n].name; n++) + ; + if (n == 0) + return; + if (commtab) + commtab = (struct commt *)realloc(commtab, sizeof(*commtab) * (ncommtab + n)); + else + commtab = (struct commt *)malloc(sizeof(*commtab) * (ncommtab + n)); + if (!commtab) + Panic(0, strnomem); + for (i = 0; i < n; i++) + { + for (j = 0; j < ncommtab; j++) + { + r = strcmp(cos[i].name, commtab[j]->name); + if (r == 0) + Panic(0, "Duplicate command: %s\n", cos[i].name); + if (r < 0) + break; + } + for (r = ncommtab; r > j; r--) + commtab[r] = commtab[r - 1]; + commtab[j] = cos + i; + cos[i].handler = hand; + bzero(cos[i].userbits, sizeof(cos[i].userbits)); + ncommtab++; + } +} + +struct comm * +FindComm(str) +char *str; +{ + int x, m, l = 0, r = ncommtab - 1; + while (l <= r) + { + m = (l + r) / 2; + x = strcmp(str, commtab[m]->name); + if (x > 0) + l = m + 1; + else if (x < 0) + r = m - 1; + else + return commtab[m]; + } + return 0; +} + +#endif + +static int +CalcSlicePercent(cv, percent) +struct canvas *cv; +int percent; +{ + int w, wsum, up; + if (!cv || !cv->c_slback) + return percent; + up = CalcSlicePercent(cv->c_slback->c_slback, percent); + w = cv->c_slweight; + for (cv = cv->c_slback->c_slperp, wsum = 0; cv; cv = cv->c_slnext) + wsum += cv->c_slweight; + if (wsum == 0) + return 0; + return (up * w) / wsum; +} + +static int +ChangeCanvasSize(fcv, abs, diff, gflag, percent) +struct canvas *fcv; /* make this canvas bigger */ +int abs; /* mode: 0:rel 1:abs 2:max */ +int diff; /* change this much */ +int gflag; /* go up if neccessary */ +int percent; +{ + struct canvas *cv; + int done, have, m, dir; + + debug3("ChangeCanvasSize abs %d diff %d percent=%d\n", abs, diff, percent); + if (abs == 0 && diff == 0) + return 0; + if (abs == 2) + { + if (diff == 0) + fcv->c_slweight = 0; + else + { + for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext) + cv->c_slweight = 0; + fcv->c_slweight = 1; + cv = fcv->c_slback->c_slback; + if (gflag && cv && cv->c_slback) + ChangeCanvasSize(cv, abs, diff, gflag, percent); + } + return diff; + } + if (abs) + { + if (diff < 0) + diff = 0; + if (percent && diff > percent) + diff = percent; + } + if (percent) + { + int wsum, up; + for (cv = fcv->c_slback->c_slperp, wsum = 0; cv; cv = cv->c_slnext) + wsum += cv->c_slweight; + if (wsum) + { + up = gflag ? CalcSlicePercent(fcv->c_slback->c_slback, percent) : percent; + debug3("up=%d, wsum=%d percent=%d\n", up, wsum, percent); + if (wsum < 1000) + { + int scale = wsum < 10 ? 1000 : 100; + for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext) + cv->c_slweight *= scale; + wsum *= scale; + debug1("scaled wsum to %d\n", wsum); + } + for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext) + { + if (cv->c_slweight) + { + cv->c_slweight = (cv->c_slweight * up) / percent; + if (cv->c_slweight == 0) + cv->c_slweight = 1; + } + debug1(" - weight %d\n", cv->c_slweight); + } + diff = (diff * wsum) / percent; + percent = wsum; + } + } + else + { + if (abs && diff == (fcv->c_slorient == SLICE_VERT ? fcv->c_ye - fcv->c_ys + 2 : fcv->c_xe - fcv->c_xs + 2)) + return 0; + /* fix weights to real size (can't be helped, sorry) */ + for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext) + { + cv->c_slweight = cv->c_slorient == SLICE_VERT ? cv->c_ye - cv->c_ys + 2 : cv->c_xe - cv->c_xs + 2; + debug1(" - weight %d\n", cv->c_slweight); + } + } + if (abs) + diff = diff - fcv->c_slweight; + debug1("diff = %d\n", diff); + if (diff == 0) + return 0; + if (diff < 0) + { + cv = fcv->c_slnext ? fcv->c_slnext : fcv->c_slprev; + fcv->c_slweight += diff; + cv->c_slweight -= diff; + return diff; + } + done = 0; + dir = 1; + for (cv = fcv->c_slnext; diff > 0; cv = dir > 0 ? cv->c_slnext : cv->c_slprev) + { + if (!cv) + { + debug1("reached end, dir is %d\n", dir); + if (dir == -1) + break; + dir = -1; + cv = fcv; + continue; + } + if (percent) + m = 1; + else + m = cv->c_slperp ? CountCanvasPerp(cv) * 2 : 2; + debug2("min is %d, have %d\n", m, cv->c_slweight); + if (cv->c_slweight > m) + { + have = cv->c_slweight - m; + if (have > diff) + have = diff; + debug1("subtract %d\n", have); + cv->c_slweight -= have; + done += have; + diff -= have; + } + } + if (diff && gflag) + { + /* need more room! */ + cv = fcv->c_slback->c_slback; + if (cv && cv->c_slback) + done += ChangeCanvasSize(fcv->c_slback->c_slback, 0, diff, gflag, percent); + } + fcv->c_slweight += done; + debug1("ChangeCanvasSize returns %d\n", done); + return done; +} + +static void +ResizeRegions(arg, flags) +char *arg; +int flags; +{ + struct canvas *cv; + int diff, l; + int gflag = 0, abs = 0, percent = 0; + int orient = 0; + + ASSERT(display); + if (!*arg) + return; + if (D_forecv->c_slorient == SLICE_UNKN) + { + Msg(0, "resize: need more than one region"); + return; + } + gflag = flags & RESIZE_FLAG_L ? 0 : 1; + orient |= flags & RESIZE_FLAG_H ? SLICE_HORI : 0; + orient |= flags & RESIZE_FLAG_V ? SLICE_VERT : 0; + if (orient == 0) + orient = D_forecv->c_slorient; + l = strlen(arg); + if (*arg == '=') + { + /* make all regions the same height */ + struct canvas *cv = gflag ? &D_canvas : D_forecv->c_slback; + if (cv->c_slperp->c_slorient & orient) + EqualizeCanvas(cv->c_slperp, gflag); + /* can't use cv->c_slorient directly as it can be D_canvas */ + if ((cv->c_slperp->c_slorient ^ (SLICE_HORI ^ SLICE_VERT)) & orient) + { + if (cv->c_slback) + { + cv = cv->c_slback; + EqualizeCanvas(cv->c_slperp, gflag); + } + else + EqualizeCanvas(cv, gflag); + } + ResizeCanvas(cv); + RecreateCanvasChain(); + RethinkDisplayViewports(); + ResizeLayersToCanvases(); + return; + } + if (!strcmp(arg, "min") || !strcmp(arg, "0")) + { + abs = 2; + diff = 0; + } + else if (!strcmp(arg, "max") || !strcmp(arg, "_")) + { + abs = 2; + diff = 1; + } + else + { + if (l > 0 && arg[l - 1] == '%') + percent = 1000; + if (*arg == '+') + diff = atoi(arg + 1); + else if (*arg == '-') + diff = -atoi(arg + 1); + else + { + diff = atoi(arg); /* +1 because of caption line */ + if (diff < 0) + diff = 0; + abs = diff == 0 ? 2 : 1; + } + } + if (!abs && !diff) + return; + if (percent) + diff = diff * percent / 100; + cv = D_forecv; + if (cv->c_slorient & orient) + ChangeCanvasSize(cv, abs, diff, gflag, percent); + if (cv->c_slback->c_slorient & orient) + ChangeCanvasSize(cv->c_slback, abs, diff, gflag, percent); + + ResizeCanvas(&D_canvas); + RecreateCanvasChain(); + RethinkDisplayViewports(); + ResizeLayersToCanvases(); + return; + +#if 0 + + if (siz + diff < 1) + diff = 1 - siz; + if (siz + diff > dsize - (nreg - 1) * 2 - 1) + diff = dsize - (nreg - 1) * 2 - 1 - siz; + if (diff == 0 || siz + diff < 1) + return; + + if (diff < 0) + { + if (D_forecv->c_next) + { + D_forecv->c_ye += diff; + D_forecv->c_next->c_ys += diff; + D_forecv->c_next->c_yoff += diff; + } + else + { + for (cv = D_cvlist; cv; cv = cv->c_next) + if (cv->c_next == D_forecv) + break; + ASSERT(cv); + cv->c_ye -= diff; + D_forecv->c_ys -= diff; + D_forecv->c_yoff -= diff; + } + } + else + { + int s, i = 0, found = 0, di = diff, d2; + s = dsize - (nreg - 1) * 2 - 1 - siz; + for (cv = D_cvlist; cv; i = cv->c_ye + 2, cv = cv->c_next) + { + if (cv == D_forecv) + { + cv->c_ye = i + (cv->c_ye - cv->c_ys) + diff; + cv->c_yoff -= cv->c_ys - i; + cv->c_ys = i; + found = 1; + continue; + } + s -= cv->c_ye - cv->c_ys; + if (!found) + { + if (s >= di) + continue; + d2 = di - s; + } + else + d2 = di > cv->c_ye - cv->c_ys ? cv->c_ye - cv->c_ys : di; + di -= d2; + cv->c_ye = i + (cv->c_ye - cv->c_ys) - d2; + cv->c_yoff -= cv->c_ys - i; + cv->c_ys = i; + } + } + RethinkDisplayViewports(); + ResizeLayersToCanvases(); +#endif +} + +static void +ResizeFin(buf, len, data) +char *buf; +int len; +char *data; +{ + int ch; + int flags = *(int *)data; + ch = ((unsigned char *)buf)[len]; + if (ch == 0) + { + ResizeRegions(buf, flags); + return; + } + if (ch == 'h') + flags ^= RESIZE_FLAG_H; + else if (ch == 'v') + flags ^= RESIZE_FLAG_V; + else if (ch == 'b') + flags |= RESIZE_FLAG_H|RESIZE_FLAG_V; + else if (ch == 'p') + flags ^= D_forecv->c_slorient == SLICE_VERT ? RESIZE_FLAG_H : RESIZE_FLAG_V; + else if (ch == 'l') + flags ^= RESIZE_FLAG_L; + else + return; + inp_setprompt(resizeprompts[flags], NULL); + *(int *)data = flags; + buf[len] = '\034'; +} + +void +SetForeCanvas(d, cv) +struct display *d; +struct canvas *cv; +{ + struct display *odisplay = display; + if (d->d_forecv == cv) + return; + + display = d; + D_forecv = cv; + if ((focusminwidth && (focusminwidth < 0 || D_forecv->c_xe - D_forecv->c_xs + 1 < focusminwidth)) || + (focusminheight && (focusminheight < 0 || D_forecv->c_ye - D_forecv->c_ys + 1 < focusminheight))) + { + ResizeCanvas(&D_canvas); + RecreateCanvasChain(); + RethinkDisplayViewports(); + ResizeLayersToCanvases(); /* redisplays */ + } + fore = D_fore = Layer2Window(D_forecv->c_layer); + if (D_other == fore) + D_other = 0; + flayer = D_forecv->c_layer; +#ifdef RXVT_OSC + if (D_xtermosc[2] || D_xtermosc[3]) + { + Activate(-1); + } + else +#endif + { + RefreshHStatus(); +#ifdef RXVT_OSC + RefreshXtermOSC(); +#endif + flayer = D_forecv->c_layer; + CV_CALL(D_forecv, LayRestore();LaySetCursor()); + WindowChanged(0, 'F'); + } + + display = odisplay; +} + +#ifdef RXVT_OSC +void +RefreshXtermOSC() +{ + int i; + struct win *p; + + p = Layer2Window(D_forecv->c_layer); + for (i = 4; i >=0; i--) + SetXtermOSC(i, p ? p->w_xtermosc[i] : 0, "\a"); +} +#endif + +int +ParseAttrColor(s1, s2, msgok) +char *s1, *s2; +int msgok; +{ + int i, n; + char *s, *ss; + int r = 0; + + s = s1; + while (*s == ' ') + s++; + ss = s; + while (*ss && *ss != ' ') + ss++; + while (*ss == ' ') + ss++; + if (*s && (s2 || *ss || !((*s >= 'a' && *s <= 'z') || (*s >= 'A' && *s <= 'Z') || *s == '.'))) + { + int mode = 0, n = 0; + if (*s == '+') + { + mode = 1; + s++; + } + else if (*s == '-') + { + mode = -1; + s++; + } + else if (*s == '!') + { + mode = 2; + s++; + } + else if (*s == '=') + s++; + if (*s >= '0' && *s <= '9') + { + n = *s++ - '0'; + if (*s >= '0' && *s <= '9') + n = n * 16 + (*s++ - '0'); + else if (*s >= 'a' && *s <= 'f') + n = n * 16 + (*s++ - ('a' - 10)); + else if (*s >= 'A' && *s <= 'F') + n = n * 16 + (*s++ - ('A' - 10)); + else if (*s && *s != ' ') + { + if (msgok) + Msg(0, "Illegal attribute hexchar '%c'", *s); + return -1; + } + } + else + { + while (*s && *s != ' ') + { + if (*s == 'd') + n |= A_DI; + else if (*s == 'u') + n |= A_US; + else if (*s == 'b') + n |= A_BD; + else if (*s == 'r') + n |= A_RV; + else if (*s == 's') + n |= A_SO; + else if (*s == 'B') + n |= A_BL; + else + { + if (msgok) + Msg(0, "Illegal attribute specifier '%c'", *s); + return -1; + } + s++; + } + } + if (*s && *s != ' ') + { + if (msgok) + Msg(0, "junk after attribute description: '%c'", *s); + return -1; + } + if (mode == -1) + r = n << 8 | n; + else if (mode == 1) + r = n << 8; + else if (mode == 2) + r = n; + else if (mode == 0) + r = 0xffff ^ n; + } + while (*s && *s == ' ') + s++; + + if (s2) + { + if (*s) + { + if (msgok) + Msg(0, "junk after description: '%c'", *s); + return -1; + } + s = s2; + while (*s && *s == ' ') + s++; + } + +#ifdef COLOR + if (*s) + { + static char costr[] = "krgybmcw d i.01234567 9 f FKRGYBMCW I "; + int numco = 0, j; + + n = 0; + if (*s == '.') + { + numco++; + n = 0x0f; + s++; + } + for (j = 0; j < 2 && *s && *s != ' '; j++) + { + for (i = 0; costr[i]; i++) + if (*s == costr[i]) + break; + if (!costr[i]) + { + if (msgok) + Msg(0, "illegal color descriptor: '%c'", *s); + return -1; + } + numco++; + n = n << 4 | (i & 15); +#ifdef COLORS16 + if (i >= 48) + n = (n & 0x20ff) | 0x200; +#endif + s++; + } + if ((n & 0xf00) == 0xf00) + n ^= 0xf00; /* clear superflous bits */ +#ifdef COLORS16 + if (n & 0x2000) + n ^= 0x2400; /* shift bit into right position */ +#endif + if (numco == 1) + n |= 0xf0; /* don't change bg color */ + if (numco != 2 && n != 0xff) + n |= 0x100; /* special invert mode */ + if (*s && *s != ' ') + { + if (msgok) + Msg(0, "junk after color description: '%c'", *s); + return -1; + } + n ^= 0xff; + r |= n << 16; + } +#endif + + while (*s && *s == ' ') + s++; + if (*s) + { + if (msgok) + Msg(0, "junk after description: '%c'", *s); + return -1; + } + debug1("ParseAttrColor %06x\n", r); + return r; +} + +/* + * Color coding: + * 0-7 normal colors + * 9 default color + * e just set intensity + * f don't change anything + * Intensity is encoded into bits 17(fg) and 18(bg). + */ +void +ApplyAttrColor(i, mc) +int i; +struct mchar *mc; +{ + debug1("ApplyAttrColor %06x\n", i); + mc->attr |= i >> 8 & 255; + mc->attr ^= i & 255; +#ifdef COLOR + i = (i >> 16) ^ 0xff; + if ((i & 0x100) != 0) + { + i &= 0xeff; + if (mc->attr & (A_SO|A_RV)) +# ifdef COLORS16 + i = ((i & 0x0f) << 4) | ((i & 0xf0) >> 4) | ((i & 0x200) << 1) | ((i & 0x400) >> 1); +# else + i = ((i & 0x0f) << 4) | ((i & 0xf0) >> 4); +# endif + } +# ifdef COLORS16 + if ((i & 0x0f) != 0x0f) + mc->attr = (mc->attr & 0xbf) | ((i >> 3) & 0x40); + if ((i & 0xf0) != 0xf0) + mc->attr = (mc->attr & 0x7f) | ((i >> 3) & 0x80); +# endif + mc->color = 0x99 ^ mc->color; + if ((i & 0x0e) == 0x0e) + i = (i & 0xf0) | (mc->color & 0x0f); + if ((i & 0xe0) == 0xe0) + i = (i & 0x0f) | (mc->color & 0xf0); + mc->color = 0x99 ^ i; + debug2("ApplyAttrColor - %02x %02x\n", mc->attr, i); +#endif +} |