| blob | 063ba16e0d472e987dbc4dfe839e08c755bc3fb4 |
1 #ifndef PUTTY_PUTTY_H\r
2 #define PUTTY_PUTTY_H\r
3 \r
4 #include <stddef.h> /* for wchar_t */\r
5 \r
6 /*\r
7 * Global variables. Most modules declare these `extern', but\r
8 * window.c will do `#define PUTTY_DO_GLOBALS' before including this\r
9 * module, and so will get them properly defined.\r
10 */\r
11 #ifndef GLOBAL\r
12 #ifdef PUTTY_DO_GLOBALS\r
13 #define GLOBAL\r
14 #else\r
15 #define GLOBAL extern\r
16 #endif\r
17 #endif\r
18 \r
19 #ifndef DONE_TYPEDEFS\r
20 #define DONE_TYPEDEFS\r
21 typedef struct conf_tag Conf;\r
22 typedef struct backend_tag Backend;\r
23 typedef struct terminal_tag Terminal;\r
24 #endif\r
25 \r
26 #include "puttyps.h"\r
27 #include "network.h"\r
28 #include "misc.h"\r
29 \r
30 /*\r
31 * Fingerprints of the PGP master keys that can be used to establish a trust\r
32 * path between an executable and other files.\r
33 */\r
34 #define PGP_MASTER_KEY_FP \\r
35 "440D E3B5 B7A1 CA85 B3CC 1718 AB58 5DC6 0467 6F7C"\r
36 #define PGP_RSA_MASTER_KEY_FP \\r
37 "8F 15 97 DA 25 30 AB 0D 88 D1 92 54 11 CF 0C 4C"\r
38 #define PGP_DSA_MASTER_KEY_FP \\r
39 "313C 3E76 4B74 C2C5 F2AE 83A8 4F5E 6DF5 6A93 B34E"\r
40 \r
41 /* Three attribute types: \r
42 * The ATTRs (normal attributes) are stored with the characters in\r
43 * the main display arrays\r
44 *\r
45 * The TATTRs (temporary attributes) are generated on the fly, they\r
46 * can overlap with characters but not with normal attributes.\r
47 *\r
48 * The LATTRs (line attributes) are an entirely disjoint space of\r
49 * flags.\r
50 * \r
51 * The DATTRs (display attributes) are internal to terminal.c (but\r
52 * defined here because their values have to match the others\r
53 * here); they reuse the TATTR_* space but are always masked off\r
54 * before sending to the front end.\r
55 *\r
56 * ATTR_INVALID is an illegal colour combination.\r
57 */\r
58 \r
59 #define TATTR_ACTCURS 0x40000000UL /* active cursor (block) */\r
60 #define TATTR_PASCURS 0x20000000UL /* passive cursor (box) */\r
61 #define TATTR_RIGHTCURS 0x10000000UL /* cursor-on-RHS */\r
62 #define TATTR_COMBINING 0x80000000UL /* combining characters */\r
63 \r
64 #define DATTR_STARTRUN 0x80000000UL /* start of redraw run */\r
65 \r
66 #define TDATTR_MASK 0xF0000000UL\r
67 #define TATTR_MASK (TDATTR_MASK)\r
68 #define DATTR_MASK (TDATTR_MASK)\r
69 \r
70 #define LATTR_NORM 0x00000000UL\r
71 #define LATTR_WIDE 0x00000001UL\r
72 #define LATTR_TOP 0x00000002UL\r
73 #define LATTR_BOT 0x00000003UL\r
74 #define LATTR_MODE 0x00000003UL\r
75 #define LATTR_WRAPPED 0x00000010UL /* this line wraps to next */\r
76 #define LATTR_WRAPPED2 0x00000020UL /* with WRAPPED: CJK wide character\r
77 wrapped to next line, so last\r
78 single-width cell is empty */\r
79 \r
80 #define ATTR_INVALID 0x03FFFFU\r
81 \r
82 /* Like Linux use the F000 page for direct to font. */\r
83 #define CSET_OEMCP 0x0000F000UL /* OEM Codepage DTF */\r
84 #define CSET_ACP 0x0000F100UL /* Ansi Codepage DTF */\r
85 \r
86 /* These are internal use overlapping with the UTF-16 surrogates */\r
87 #define CSET_ASCII 0x0000D800UL /* normal ASCII charset ESC ( B */\r
88 #define CSET_LINEDRW 0x0000D900UL /* line drawing charset ESC ( 0 */\r
89 #define CSET_SCOACS 0x0000DA00UL /* SCO Alternate charset */\r
90 #define CSET_GBCHR 0x0000DB00UL /* UK variant charset ESC ( A */\r
91 #define CSET_MASK 0xFFFFFF00UL /* Character set mask */\r
92 \r
93 #define DIRECT_CHAR(c) ((c&0xFFFFFC00)==0xD800)\r
94 #define DIRECT_FONT(c) ((c&0xFFFFFE00)==0xF000)\r
95 \r
96 #define UCSERR (CSET_LINEDRW|'a') /* UCS Format error character. */\r
97 /*\r
98 * UCSWIDE is a special value used in the terminal data to signify\r
99 * the character cell containing the right-hand half of a CJK wide\r
100 * character. We use 0xDFFF because it's part of the surrogate\r
101 * range and hence won't be used for anything else (it's impossible\r
102 * to input it via UTF-8 because our UTF-8 decoder correctly\r
103 * rejects surrogates).\r
104 */\r
105 #define UCSWIDE 0xDFFF\r
106 \r
107 #define ATTR_NARROW 0x800000U\r
108 #define ATTR_WIDE 0x400000U\r
109 #define ATTR_BOLD 0x040000U\r
110 #define ATTR_UNDER 0x080000U\r
111 #define ATTR_REVERSE 0x100000U\r
112 #define ATTR_BLINK 0x200000U\r
113 #define ATTR_FGMASK 0x0001FFU\r
114 #define ATTR_BGMASK 0x03FE00U\r
115 #define ATTR_COLOURS 0x03FFFFU\r
116 #define ATTR_FGSHIFT 0\r
117 #define ATTR_BGSHIFT 9\r
118 \r
119 /*\r
120 * The definitive list of colour numbers stored in terminal\r
121 * attribute words is kept here. It is:\r
122 * \r
123 * - 0-7 are ANSI colours (KRGYBMCW).\r
124 * - 8-15 are the bold versions of those colours.\r
125 * - 16-255 are the remains of the xterm 256-colour mode (a\r
126 * 216-colour cube with R at most significant and B at least,\r
127 * followed by a uniform series of grey shades running between\r
128 * black and white but not including either on grounds of\r
129 * redundancy).\r
130 * - 256 is default foreground\r
131 * - 257 is default bold foreground\r
132 * - 258 is default background\r
133 * - 259 is default bold background\r
134 * - 260 is cursor foreground\r
135 * - 261 is cursor background\r
136 */\r
137 \r
138 #define ATTR_DEFFG (256 << ATTR_FGSHIFT)\r
139 #define ATTR_DEFBG (258 << ATTR_BGSHIFT)\r
140 #define ATTR_DEFAULT (ATTR_DEFFG | ATTR_DEFBG)\r
141 \r
142 struct sesslist {\r
143 int nsessions;\r
144 char **sessions;\r
145 char *buffer; /* so memory can be freed later */\r
146 };\r
147 \r
148 struct unicode_data {\r
149 char **uni_tbl;\r
150 int dbcs_screenfont;\r
151 int font_codepage;\r
152 int line_codepage;\r
153 wchar_t unitab_scoacs[256];\r
154 wchar_t unitab_line[256];\r
155 wchar_t unitab_font[256];\r
156 wchar_t unitab_xterm[256];\r
157 wchar_t unitab_oemcp[256];\r
158 unsigned char unitab_ctrl[256];\r
159 };\r
160 \r
161 #define LGXF_OVR 1 /* existing logfile overwrite */\r
162 #define LGXF_APN 0 /* existing logfile append */\r
163 #define LGXF_ASK -1 /* existing logfile ask */\r
164 #define LGTYP_NONE 0 /* logmode: no logging */\r
165 #define LGTYP_ASCII 1 /* logmode: pure ascii */\r
166 #define LGTYP_DEBUG 2 /* logmode: all chars of traffic */\r
167 #define LGTYP_PACKETS 3 /* logmode: SSH data packets */\r
168 #define LGTYP_SSHRAW 4 /* logmode: SSH raw data */\r
169 \r
170 typedef enum {\r
171 /* Actual special commands. Originally Telnet, but some codes have\r
172 * been re-used for similar specials in other protocols. */\r
173 TS_AYT, TS_BRK, TS_SYNCH, TS_EC, TS_EL, TS_GA, TS_NOP, TS_ABORT,\r
174 TS_AO, TS_IP, TS_SUSP, TS_EOR, TS_EOF, TS_LECHO, TS_RECHO, TS_PING,\r
175 TS_EOL,\r
176 /* Special command for SSH. */\r
177 TS_REKEY,\r
178 /* POSIX-style signals. (not Telnet) */\r
179 TS_SIGABRT, TS_SIGALRM, TS_SIGFPE, TS_SIGHUP, TS_SIGILL,\r
180 TS_SIGINT, TS_SIGKILL, TS_SIGPIPE, TS_SIGQUIT, TS_SIGSEGV,\r
181 TS_SIGTERM, TS_SIGUSR1, TS_SIGUSR2,\r
182 /* Pseudo-specials used for constructing the specials menu. */\r
183 TS_SEP, /* Separator */\r
184 TS_SUBMENU, /* Start a new submenu with specified name */\r
185 TS_EXITMENU /* Exit current submenu or end of specials */\r
186 } Telnet_Special;\r
187 \r
188 struct telnet_special {\r
189 const char *name;\r
190 int code;\r
191 };\r
192 \r
193 typedef enum {\r
194 MBT_NOTHING,\r
195 MBT_LEFT, MBT_MIDDLE, MBT_RIGHT, /* `raw' button designations */\r
196 MBT_SELECT, MBT_EXTEND, MBT_PASTE, /* `cooked' button designations */\r
197 MBT_WHEEL_UP, MBT_WHEEL_DOWN /* mouse wheel */\r
198 } Mouse_Button;\r
199 \r
200 typedef enum {\r
201 MA_NOTHING, MA_CLICK, MA_2CLK, MA_3CLK, MA_DRAG, MA_RELEASE\r
202 } Mouse_Action;\r
203 \r
204 /* Keyboard modifiers -- keys the user is actually holding down */\r
205 \r
206 #define PKM_SHIFT 0x01\r
207 #define PKM_CONTROL 0x02\r
208 #define PKM_META 0x04\r
209 #define PKM_ALT 0x08\r
210 \r
211 /* Keyboard flags that aren't really modifiers */\r
212 #define PKF_CAPSLOCK 0x10\r
213 #define PKF_NUMLOCK 0x20\r
214 #define PKF_REPEAT 0x40\r
215 \r
216 /* Stand-alone keysyms for function keys */\r
217 \r
218 typedef enum {\r
219 PK_NULL, /* No symbol for this key */\r
220 /* Main keypad keys */\r
221 PK_ESCAPE, PK_TAB, PK_BACKSPACE, PK_RETURN, PK_COMPOSE,\r
222 /* Editing keys */\r
223 PK_HOME, PK_INSERT, PK_DELETE, PK_END, PK_PAGEUP, PK_PAGEDOWN,\r
224 /* Cursor keys */\r
225 PK_UP, PK_DOWN, PK_RIGHT, PK_LEFT, PK_REST,\r
226 /* Numeric keypad */ /* Real one looks like: */\r
227 PK_PF1, PK_PF2, PK_PF3, PK_PF4, /* PF1 PF2 PF3 PF4 */\r
228 PK_KPCOMMA, PK_KPMINUS, PK_KPDECIMAL, /* 7 8 9 - */\r
229 PK_KP0, PK_KP1, PK_KP2, PK_KP3, PK_KP4, /* 4 5 6 , */\r
230 PK_KP5, PK_KP6, PK_KP7, PK_KP8, PK_KP9, /* 1 2 3 en- */\r
231 PK_KPBIGPLUS, PK_KPENTER, /* 0 . ter */\r
232 /* Top row */\r
233 PK_F1, PK_F2, PK_F3, PK_F4, PK_F5,\r
234 PK_F6, PK_F7, PK_F8, PK_F9, PK_F10,\r
235 PK_F11, PK_F12, PK_F13, PK_F14, PK_F15,\r
236 PK_F16, PK_F17, PK_F18, PK_F19, PK_F20,\r
237 PK_PAUSE\r
238 } Key_Sym;\r
239 \r
240 #define PK_ISEDITING(k) ((k) >= PK_HOME && (k) <= PK_PAGEDOWN)\r
241 #define PK_ISCURSOR(k) ((k) >= PK_UP && (k) <= PK_REST)\r
242 #define PK_ISKEYPAD(k) ((k) >= PK_PF1 && (k) <= PK_KPENTER)\r
243 #define PK_ISFKEY(k) ((k) >= PK_F1 && (k) <= PK_F20)\r
244 \r
245 enum {\r
246 VT_XWINDOWS, VT_OEMANSI, VT_OEMONLY, VT_POORMAN, VT_UNICODE\r
247 };\r
248 \r
249 enum {\r
250 /*\r
251 * SSH-2 key exchange algorithms\r
252 */\r
253 KEX_WARN,\r
254 KEX_DHGROUP1,\r
255 KEX_DHGROUP14,\r
256 KEX_DHGEX,\r
257 KEX_RSA,\r
258 KEX_MAX\r
259 };\r
260 \r
261 enum {\r
262 /*\r
263 * SSH ciphers (both SSH-1 and SSH-2)\r
264 */\r
265 CIPHER_WARN, /* pseudo 'cipher' */\r
266 CIPHER_3DES,\r
267 CIPHER_BLOWFISH,\r
268 CIPHER_AES, /* (SSH-2 only) */\r
269 CIPHER_DES,\r
270 CIPHER_ARCFOUR,\r
271 CIPHER_MAX /* no. ciphers (inc warn) */\r
272 };\r
273 \r
274 enum {\r
275 /*\r
276 * Several different bits of the PuTTY configuration seem to be\r
277 * three-way settings whose values are `always yes', `always\r
278 * no', and `decide by some more complex automated means'. This\r
279 * is true of line discipline options (local echo and line\r
280 * editing), proxy DNS, Close On Exit, and SSH server bug\r
281 * workarounds. Accordingly I supply a single enum here to deal\r
282 * with them all.\r
283 */\r
284 FORCE_ON, FORCE_OFF, AUTO\r
285 };\r
286 \r
287 enum {\r
288 /*\r
289 * Proxy types.\r
290 */\r
291 PROXY_NONE, PROXY_SOCKS4, PROXY_SOCKS5,\r
292 PROXY_HTTP, PROXY_TELNET, PROXY_CMD\r
293 };\r
294 \r
295 enum {\r
296 /*\r
297 * Line discipline options which the backend might try to control.\r
298 */\r
299 LD_EDIT, /* local line editing */\r
300 LD_ECHO /* local echo */\r
301 };\r
302 \r
303 enum {\r
304 /* Actions on remote window title query */\r
305 TITLE_NONE, TITLE_EMPTY, TITLE_REAL\r
306 };\r
307 \r
308 enum {\r
309 /* Protocol back ends. (CONF_protocol) */\r
310 PROT_RAW, PROT_TELNET, PROT_RLOGIN, PROT_SSH,\r
311 /* PROT_SERIAL is supported on a subset of platforms, but it doesn't\r
312 * hurt to define it globally. */\r
313 PROT_SERIAL\r
314 };\r
315 \r
316 enum {\r
317 /* Bell settings (CONF_beep) */\r
318 BELL_DISABLED, BELL_DEFAULT, BELL_VISUAL, BELL_WAVEFILE, BELL_PCSPEAKER\r
319 };\r
320 \r
321 enum {\r
322 /* Taskbar flashing indication on bell (CONF_beep_ind) */\r
323 B_IND_DISABLED, B_IND_FLASH, B_IND_STEADY\r
324 };\r
325 \r
326 enum {\r
327 /* Resize actions (CONF_resize_action) */\r
328 RESIZE_TERM, RESIZE_DISABLED, RESIZE_FONT, RESIZE_EITHER\r
329 };\r
330 \r
331 enum {\r
332 /* Function key types (CONF_funky_type) */\r
333 FUNKY_TILDE,\r
334 FUNKY_LINUX,\r
335 FUNKY_XTERM,\r
336 FUNKY_VT400,\r
337 FUNKY_VT100P,\r
338 FUNKY_SCO\r
339 };\r
340 \r
341 enum {\r
342 FQ_DEFAULT, FQ_ANTIALIASED, FQ_NONANTIALIASED, FQ_CLEARTYPE\r
343 };\r
344 \r
345 enum {\r
346 SER_PAR_NONE, SER_PAR_ODD, SER_PAR_EVEN, SER_PAR_MARK, SER_PAR_SPACE\r
347 };\r
348 \r
349 enum {\r
350 SER_FLOW_NONE, SER_FLOW_XONXOFF, SER_FLOW_RTSCTS, SER_FLOW_DSRDTR\r
351 };\r
352 \r
353 /*\r
354 * Tables of string <-> enum value mappings used in settings.c.\r
355 * Defined here so that backends can export their GSS library tables\r
356 * to the cross-platform settings code.\r
357 */\r
358 struct keyvalwhere {\r
359 /*\r
360 * Two fields which define a string and enum value to be\r
361 * equivalent to each other.\r
362 */\r
363 char *s;\r
364 int v;\r
365 \r
366 /*\r
367 * The next pair of fields are used by gprefs() in settings.c to\r
368 * arrange that when it reads a list of strings representing a\r
369 * preference list and translates it into the corresponding list\r
370 * of integers, strings not appearing in the list are entered in a\r
371 * configurable position rather than uniformly at the end.\r
372 */\r
373 \r
374 /*\r
375 * 'vrel' indicates which other value in the list to place this\r
376 * element relative to. It should be a value that has occurred in\r
377 * a 'v' field of some other element of the array, or -1 to\r
378 * indicate that we simply place relative to one or other end of\r
379 * the list.\r
380 *\r
381 * gprefs will try to process the elements in an order which makes\r
382 * this field work (i.e. so that the element referenced has been\r
383 * added before processing this one).\r
384 */\r
385 int vrel;\r
386 \r
387 /*\r
388 * 'where' indicates whether to place the new value before or\r
389 * after the one referred to by vrel. -1 means before; +1 means\r
390 * after.\r
391 *\r
392 * When vrel is -1, this also implicitly indicates which end of\r
393 * the array to use. So vrel=-1, where=-1 means to place _before_\r
394 * some end of the list (hence, at the last element); vrel=-1,\r
395 * where=+1 means to place _after_ an end (hence, at the first).\r
396 */\r
397 int where;\r
398 };\r
399 \r
400 #ifndef NO_GSSAPI\r
401 extern const int ngsslibs;\r
402 extern const char *const gsslibnames[]; /* for displaying in configuration */\r
403 extern const struct keyvalwhere gsslibkeywords[]; /* for settings.c */\r
404 #endif\r
405 \r
406 extern const char *const ttymodes[];\r
407 \r
408 enum {\r
409 /*\r
410 * Network address types. Used for specifying choice of IPv4/v6\r
411 * in config; also used in proxy.c to indicate whether a given\r
412 * host name has already been resolved or will be resolved at\r
413 * the proxy end.\r
414 */\r
415 ADDRTYPE_UNSPEC, ADDRTYPE_IPV4, ADDRTYPE_IPV6, ADDRTYPE_NAME\r
416 };\r
417 \r
418 struct backend_tag {\r
419 const char *(*init) (void *frontend_handle, void **backend_handle,\r
420 Conf *conf, char *host, int port, char **realhost,\r
421 int nodelay, int keepalive);\r
422 void (*free) (void *handle);\r
423 /* back->reconfig() passes in a replacement configuration. */\r
424 void (*reconfig) (void *handle, Conf *conf);\r
425 /* back->send() returns the current amount of buffered data. */\r
426 int (*send) (void *handle, char *buf, int len);\r
427 /* back->sendbuffer() does the same thing but without attempting a send */\r
428 int (*sendbuffer) (void *handle);\r
429 void (*size) (void *handle, int width, int height);\r
430 void (*special) (void *handle, Telnet_Special code);\r
431 const struct telnet_special *(*get_specials) (void *handle);\r
432 int (*connected) (void *handle);\r
433 int (*exitcode) (void *handle);\r
434 /* If back->sendok() returns FALSE, data sent to it from the frontend\r
435 * may be lost. */\r
436 int (*sendok) (void *handle);\r
437 int (*ldisc) (void *handle, int);\r
438 void (*provide_ldisc) (void *handle, void *ldisc);\r
439 void (*provide_logctx) (void *handle, void *logctx);\r
440 /*\r
441 * back->unthrottle() tells the back end that the front end\r
442 * buffer is clearing.\r
443 */\r
444 void (*unthrottle) (void *handle, int);\r
445 int (*cfg_info) (void *handle);\r
446 char *name;\r
447 int protocol;\r
448 int default_port;\r
449 };\r
450 \r
451 extern Backend *backends[];\r
452 \r
453 /*\r
454 * Suggested default protocol provided by the backend link module.\r
455 * The application is free to ignore this.\r
456 */\r
457 extern const int be_default_protocol;\r
458 \r
459 /*\r
460 * Name of this particular application, for use in the config box\r
461 * and other pieces of text.\r
462 */\r
463 extern const char *const appname;\r
464 \r
465 /*\r
466 * Some global flags denoting the type of application.\r
467 * \r
468 * FLAG_VERBOSE is set when the user requests verbose details.\r
469 * \r
470 * FLAG_STDERR is set in command-line applications (which have a\r
471 * functioning stderr that it makes sense to write to) and not in\r
472 * GUI applications (which don't).\r
473 * \r
474 * FLAG_INTERACTIVE is set when a full interactive shell session is\r
475 * being run, _either_ because no remote command has been provided\r
476 * _or_ because the application is GUI and can't run non-\r
477 * interactively.\r
478 * \r
479 * These flags describe the type of _application_ - they wouldn't\r
480 * vary between individual sessions - and so it's OK to have this\r
481 * variable be GLOBAL.\r
482 * \r
483 * Note that additional flags may be defined in platform-specific\r
484 * headers. It's probably best if those ones start from 0x1000, to\r
485 * avoid collision.\r
486 */\r
487 #define FLAG_VERBOSE 0x0001\r
488 #define FLAG_STDERR 0x0002\r
489 #define FLAG_INTERACTIVE 0x0004\r
490 GLOBAL int flags;\r
491 \r
492 /*\r
493 * Likewise, these two variables are set up when the application\r
494 * initialises, and inform all default-settings accesses after\r
495 * that.\r
496 */\r
497 GLOBAL int default_protocol;\r
498 GLOBAL int default_port;\r
499 \r
500 /*\r
501 * This is set TRUE by cmdline.c iff a session is loaded with "-load".\r
502 */\r
503 GLOBAL int loaded_session;\r
504 /*\r
505 * This is set to the name of the loaded session.\r
506 */\r
507 GLOBAL char *cmdline_session_name;\r
508 \r
509 struct RSAKey; /* be a little careful of scope */\r
510 \r
511 /*\r
512 * Mechanism for getting text strings such as usernames and passwords\r
513 * from the front-end.\r
514 * The fields are mostly modelled after SSH's keyboard-interactive auth.\r
515 * FIXME We should probably mandate a character set/encoding (probably UTF-8).\r
516 *\r
517 * Since many of the pieces of text involved may be chosen by the server,\r
518 * the caller must take care to ensure that the server can't spoof locally-\r
519 * generated prompts such as key passphrase prompts. Some ground rules:\r
520 * - If the front-end needs to truncate a string, it should lop off the\r
521 * end.\r
522 * - The front-end should filter out any dangerous characters and\r
523 * generally not trust the strings. (But \n is required to behave\r
524 * vaguely sensibly, at least in `instruction', and ideally in\r
525 * `prompt[]' too.)\r
526 */\r
527 typedef struct {\r
528 char *prompt;\r
529 int echo;\r
530 /*\r
531 * 'result' must be a dynamically allocated array of exactly\r
532 * 'resultsize' chars. The code for actually reading input may\r
533 * realloc it bigger (and adjust resultsize accordingly) if it has\r
534 * to. The caller should free it again when finished with it.\r
535 *\r
536 * If resultsize==0, then result may be NULL. When setting up a\r
537 * prompt_t, it's therefore easiest to initialise them this way,\r
538 * which means all actual allocation is done by the callee. This\r
539 * is what add_prompt does.\r
540 */\r
541 char *result;\r
542 size_t resultsize;\r
543 } prompt_t;\r
544 typedef struct {\r
545 /*\r
546 * Indicates whether the information entered is to be used locally\r
547 * (for instance a key passphrase prompt), or is destined for the wire.\r
548 * This is a hint only; the front-end is at liberty not to use this\r
549 * information (so the caller should ensure that the supplied text is\r
550 * sufficient).\r
551 */\r
552 int to_server;\r
553 char *name; /* Short description, perhaps for dialog box title */\r
554 int name_reqd; /* Display of `name' required or optional? */\r
555 char *instruction; /* Long description, maybe with embedded newlines */\r
556 int instr_reqd; /* Display of `instruction' required or optional? */\r
557 size_t n_prompts; /* May be zero (in which case display the foregoing,\r
558 * if any, and return success) */\r
559 prompt_t **prompts;\r
560 void *frontend;\r
561 void *data; /* slot for housekeeping data, managed by\r
562 * get_userpass_input(); initially NULL */\r
563 } prompts_t;\r
564 prompts_t *new_prompts(void *frontend);\r
565 void add_prompt(prompts_t *p, char *promptstr, int echo);\r
566 void prompt_set_result(prompt_t *pr, const char *newstr);\r
567 void prompt_ensure_result_size(prompt_t *pr, int len);\r
568 /* Burn the evidence. (Assumes _all_ strings want free()ing.) */\r
569 void free_prompts(prompts_t *p);\r
570 \r
571 /*\r
572 * Exports from the front end.\r
573 */\r
574 void request_resize(void *frontend, int, int);\r
575 void do_text(Context, int, int, wchar_t *, int, unsigned long, int);\r
576 void do_cursor(Context, int, int, wchar_t *, int, unsigned long, int);\r
577 int char_width(Context ctx, int uc);\r
578 #ifdef OPTIMISE_SCROLL\r
579 void do_scroll(Context, int, int, int);\r
580 #endif\r
581 void set_title(void *frontend, char *);\r
582 void set_icon(void *frontend, char *);\r
583 void set_sbar(void *frontend, int, int, int);\r
584 Context get_ctx(void *frontend);\r
585 void free_ctx(Context);\r
586 void palette_set(void *frontend, int, int, int, int);\r
587 void palette_reset(void *frontend);\r
588 void write_aclip(void *frontend, char *, int, int);\r
589 void write_clip(void *frontend, wchar_t *, int *, int, int);\r
590 void get_clip(void *frontend, wchar_t **, int *);\r
591 void optimised_move(void *frontend, int, int, int);\r
592 void set_raw_mouse_mode(void *frontend, int);\r
593 void connection_fatal(void *frontend, char *, ...);\r
594 void nonfatal(char *, ...);\r
595 void fatalbox(char *, ...);\r
596 void modalfatalbox(char *, ...);\r
597 #ifdef macintosh\r
598 #pragma noreturn(fatalbox)\r
599 #pragma noreturn(modalfatalbox)\r
600 #endif\r
601 void do_beep(void *frontend, int);\r
602 void begin_session(void *frontend);\r
603 void sys_cursor(void *frontend, int x, int y);\r
604 void request_paste(void *frontend);\r
605 void frontend_keypress(void *frontend);\r
606 void ldisc_update(void *frontend, int echo, int edit);\r
607 /* It's the backend's responsibility to invoke this at the start of a\r
608 * connection, if necessary; it can also invoke it later if the set of\r
609 * special commands changes. It does not need to invoke it at session\r
610 * shutdown. */\r
611 void update_specials_menu(void *frontend);\r
612 int from_backend(void *frontend, int is_stderr, const char *data, int len);\r
613 int from_backend_untrusted(void *frontend, const char *data, int len);\r
614 /* Called when the back end wants to indicate that EOF has arrived on\r
615 * the server-to-client stream. Returns FALSE to indicate that we\r
616 * intend to keep the session open in the other direction, or TRUE to\r
617 * indicate that if they're closing so are we. */\r
618 int from_backend_eof(void *frontend);\r
619 void notify_remote_exit(void *frontend);\r
620 /* Get a sensible value for a tty mode. NULL return = don't set.\r
621 * Otherwise, returned value should be freed by caller. */\r
622 char *get_ttymode(void *frontend, const char *mode);\r
623 /*\r
624 * >0 = `got all results, carry on'\r
625 * 0 = `user cancelled' (FIXME distinguish "give up entirely" and "next auth"?)\r
626 * <0 = `please call back later with more in/inlen'\r
627 */\r
628 int get_userpass_input(prompts_t *p, unsigned char *in, int inlen);\r
629 #define OPTIMISE_IS_SCROLL 1\r
630 \r
631 void set_iconic(void *frontend, int iconic);\r
632 void move_window(void *frontend, int x, int y);\r
633 void set_zorder(void *frontend, int top);\r
634 void refresh_window(void *frontend);\r
635 void set_zoomed(void *frontend, int zoomed);\r
636 int is_iconic(void *frontend);\r
637 void get_window_pos(void *frontend, int *x, int *y);\r
638 void get_window_pixels(void *frontend, int *x, int *y);\r
639 char *get_window_title(void *frontend, int icon);\r
640 /* Hint from backend to frontend about time-consuming operations.\r
641 * Initial state is assumed to be BUSY_NOT. */\r
642 enum {\r
643 BUSY_NOT, /* Not busy, all user interaction OK */\r
644 BUSY_WAITING, /* Waiting for something; local event loops still running\r
645 so some local interaction (e.g. menus) OK, but network\r
646 stuff is suspended */\r
647 BUSY_CPU /* Locally busy (e.g. crypto); user interaction suspended */\r
648 };\r
649 void set_busy_status(void *frontend, int status);\r
650 \r
651 void cleanup_exit(int);\r
652 \r
653 /*\r
654 * Exports from conf.c, and a big enum (via parametric macro) of\r
655 * configuration option keys.\r
656 */\r
657 #define CONFIG_OPTIONS(X) \\r
658 /* X(value-type, subkey-type, keyword) */ \\r
659 X(STR, NONE, host) \\r
660 X(INT, NONE, port) \\r
661 X(INT, NONE, protocol) \\r
662 X(INT, NONE, addressfamily) \\r
663 X(INT, NONE, close_on_exit) \\r
664 X(INT, NONE, warn_on_close) \\r
665 X(INT, NONE, ping_interval) /* in seconds */ \\r
666 X(INT, NONE, tcp_nodelay) \\r
667 X(INT, NONE, tcp_keepalives) \\r
668 X(STR, NONE, loghost) /* logical host being contacted, for host key check */ \\r
669 /* Proxy options */ \\r
670 X(STR, NONE, proxy_exclude_list) \\r
671 X(INT, NONE, proxy_dns) \\r
672 X(INT, NONE, even_proxy_localhost) \\r
673 X(INT, NONE, proxy_type) \\r
674 X(STR, NONE, proxy_host) \\r
675 X(INT, NONE, proxy_port) \\r
676 X(STR, NONE, proxy_username) \\r
677 X(STR, NONE, proxy_password) \\r
678 X(STR, NONE, proxy_telnet_command) \\r
679 /* SSH options */ \\r
680 X(STR, NONE, remote_cmd) \\r
681 X(STR, NONE, remote_cmd2) /* fallback if remote_cmd fails; never loaded or saved */ \\r
682 X(INT, NONE, nopty) \\r
683 X(INT, NONE, compression) \\r
684 X(INT, INT, ssh_kexlist) \\r
685 X(INT, NONE, ssh_rekey_time) /* in minutes */ \\r
686 X(STR, NONE, ssh_rekey_data) /* string encoding e.g. "100K", "2M", "1G" */ \\r
687 X(INT, NONE, tryagent) \\r
688 X(INT, NONE, agentfwd) \\r
689 X(INT, NONE, change_username) /* allow username switching in SSH-2 */ \\r
690 X(INT, INT, ssh_cipherlist) \\r
691 X(FILENAME, NONE, keyfile) \\r
692 X(INT, NONE, sshprot) /* use v1 or v2 when both available */ \\r
693 X(INT, NONE, ssh2_des_cbc) /* "des-cbc" unrecommended SSH-2 cipher */ \\r
694 X(INT, NONE, ssh_no_userauth) /* bypass "ssh-userauth" (SSH-2 only) */ \\r
695 X(INT, NONE, ssh_show_banner) /* show USERAUTH_BANNERs (SSH-2 only) */ \\r
696 X(INT, NONE, try_tis_auth) \\r
697 X(INT, NONE, try_ki_auth) \\r
698 X(INT, NONE, try_gssapi_auth) /* attempt gssapi auth */ \\r
699 X(INT, NONE, gssapifwd) /* forward tgt via gss */ \\r
700 X(INT, INT, ssh_gsslist) /* preference order for local GSS libs */ \\r
701 X(FILENAME, NONE, ssh_gss_custom) \\r
702 X(INT, NONE, ssh_subsys) /* run a subsystem rather than a command */ \\r
703 X(INT, NONE, ssh_subsys2) /* fallback to go with remote_cmd_ptr2 */ \\r
704 X(INT, NONE, ssh_no_shell) /* avoid running a shell */ \\r
705 X(STR, NONE, ssh_nc_host) /* host to connect to in `nc' mode */ \\r
706 X(INT, NONE, ssh_nc_port) /* port to connect to in `nc' mode */ \\r
707 /* Telnet options */ \\r
708 X(STR, NONE, termtype) \\r
709 X(STR, NONE, termspeed) \\r
710 X(STR, STR, ttymodes) /* values are "Vvalue" or "A" */ \\r
711 X(STR, STR, environmt) \\r
712 X(STR, NONE, username) \\r
713 X(INT, NONE, username_from_env) \\r
714 X(STR, NONE, localusername) \\r
715 X(INT, NONE, rfc_environ) \\r
716 X(INT, NONE, passive_telnet) \\r
717 /* Serial port options */ \\r
718 X(STR, NONE, serline) \\r
719 X(INT, NONE, serspeed) \\r
720 X(INT, NONE, serdatabits) \\r
721 X(INT, NONE, serstopbits) \\r
722 X(INT, NONE, serparity) \\r
723 X(INT, NONE, serflow) \\r
724 /* Keyboard options */ \\r
725 X(INT, NONE, bksp_is_delete) \\r
726 X(INT, NONE, rxvt_homeend) \\r
727 X(INT, NONE, funky_type) \\r
728 X(INT, NONE, no_applic_c) /* totally disable app cursor keys */ \\r
729 X(INT, NONE, no_applic_k) /* totally disable app keypad */ \\r
730 X(INT, NONE, no_mouse_rep) /* totally disable mouse reporting */ \\r
731 X(INT, NONE, no_remote_resize) /* disable remote resizing */ \\r
732 X(INT, NONE, no_alt_screen) /* disable alternate screen */ \\r
733 X(INT, NONE, no_remote_wintitle) /* disable remote retitling */ \\r
734 X(INT, NONE, no_dbackspace) /* disable destructive backspace */ \\r
735 X(INT, NONE, no_remote_charset) /* disable remote charset config */ \\r
736 X(INT, NONE, remote_qtitle_action) /* remote win title query action */ \\r
737 X(INT, NONE, app_cursor) \\r
738 X(INT, NONE, app_keypad) \\r
739 X(INT, NONE, nethack_keypad) \\r
740 X(INT, NONE, telnet_keyboard) \\r
741 X(INT, NONE, telnet_newline) \\r
742 X(INT, NONE, alt_f4) /* is it special? */ \\r
743 X(INT, NONE, alt_space) /* is it special? */ \\r
744 X(INT, NONE, alt_only) /* is it special? */ \\r
745 X(INT, NONE, localecho) \\r
746 X(INT, NONE, localedit) \\r
747 X(INT, NONE, alwaysontop) \\r
748 X(INT, NONE, fullscreenonaltenter) \\r
749 X(INT, NONE, scroll_on_key) \\r
750 X(INT, NONE, scroll_on_disp) \\r
751 X(INT, NONE, erase_to_scrollback) \\r
752 X(INT, NONE, compose_key) \\r
753 X(INT, NONE, ctrlaltkeys) \\r
754 X(STR, NONE, wintitle) /* initial window title */ \\r
755 /* Terminal options */ \\r
756 X(INT, NONE, savelines) \\r
757 X(INT, NONE, dec_om) \\r
758 X(INT, NONE, wrap_mode) \\r
759 X(INT, NONE, lfhascr) \\r
760 X(INT, NONE, cursor_type) /* 0=block 1=underline 2=vertical */ \\r
761 X(INT, NONE, blink_cur) \\r
762 X(INT, NONE, beep) \\r
763 X(INT, NONE, beep_ind) \\r
764 X(INT, NONE, bellovl) /* bell overload protection active? */ \\r
765 X(INT, NONE, bellovl_n) /* number of bells to cause overload */ \\r
766 X(INT, NONE, bellovl_t) /* time interval for overload (seconds) */ \\r
767 X(INT, NONE, bellovl_s) /* period of silence to re-enable bell (s) */ \\r
768 X(FILENAME, NONE, bell_wavefile) \\r
769 X(INT, NONE, scrollbar) \\r
770 X(INT, NONE, scrollbar_in_fullscreen) \\r
771 X(INT, NONE, resize_action) \\r
772 X(INT, NONE, bce) \\r
773 X(INT, NONE, blinktext) \\r
774 X(INT, NONE, win_name_always) \\r
775 X(INT, NONE, width) \\r
776 X(INT, NONE, height) \\r
777 X(FONT, NONE, font) \\r
778 X(INT, NONE, font_quality) \\r
779 X(FILENAME, NONE, logfilename) \\r
780 X(INT, NONE, logtype) \\r
781 X(INT, NONE, logxfovr) \\r
782 X(INT, NONE, logflush) \\r
783 X(INT, NONE, logomitpass) \\r
784 X(INT, NONE, logomitdata) \\r
785 X(INT, NONE, hide_mouseptr) \\r
786 X(INT, NONE, sunken_edge) \\r
787 X(INT, NONE, window_border) \\r
788 X(STR, NONE, answerback) \\r
789 X(STR, NONE, printer) \\r
790 X(INT, NONE, arabicshaping) \\r
791 X(INT, NONE, bidi) \\r
792 /* Colour options */ \\r
793 X(INT, NONE, ansi_colour) \\r
794 X(INT, NONE, xterm_256_colour) \\r
795 X(INT, NONE, system_colour) \\r
796 X(INT, NONE, try_palette) \\r
797 X(INT, NONE, bold_style) \\r
798 X(INT, INT, colours) \\r
799 /* Selection options */ \\r
800 X(INT, NONE, mouse_is_xterm) \\r
801 X(INT, NONE, rect_select) \\r
802 X(INT, NONE, rawcnp) \\r
803 X(INT, NONE, rtf_paste) \\r
804 X(INT, NONE, mouse_override) \\r
805 X(INT, INT, wordness) \\r
806 /* translations */ \\r
807 X(INT, NONE, vtmode) \\r
808 X(STR, NONE, line_codepage) \\r
809 X(INT, NONE, cjk_ambig_wide) \\r
810 X(INT, NONE, utf8_override) \\r
811 X(INT, NONE, xlat_capslockcyr) \\r
812 /* X11 forwarding */ \\r
813 X(INT, NONE, x11_forward) \\r
814 X(STR, NONE, x11_display) \\r
815 X(INT, NONE, x11_auth) \\r
816 X(FILENAME, NONE, xauthfile) \\r
817 /* port forwarding */ \\r
818 X(INT, NONE, lport_acceptall) /* accept conns from hosts other than localhost */ \\r
819 X(INT, NONE, rport_acceptall) /* same for remote forwarded ports (SSH-2 only) */ \\r
820 /* \\r
821 * Subkeys for 'portfwd' can have the following forms: \\r
822 * \\r
823 * [LR]localport \\r
824 * [LR]localaddr:localport \\r
825 * \\r
826 * Dynamic forwardings are indicated by an 'L' key, and the \\r
827 * special value "D". For all other forwardings, the value \\r
828 * should be of the form 'host:port'. \\r
829 */ \\r
830 X(STR, STR, portfwd) \\r
831 /* SSH bug compatibility modes */ \\r
832 X(INT, NONE, sshbug_ignore1) \\r
833 X(INT, NONE, sshbug_plainpw1) \\r
834 X(INT, NONE, sshbug_rsa1) \\r
835 X(INT, NONE, sshbug_hmac2) \\r
836 X(INT, NONE, sshbug_derivekey2) \\r
837 X(INT, NONE, sshbug_rsapad2) \\r
838 X(INT, NONE, sshbug_pksessid2) \\r
839 X(INT, NONE, sshbug_rekey2) \\r
840 X(INT, NONE, sshbug_maxpkt2) \\r
841 X(INT, NONE, sshbug_ignore2) \\r
842 X(INT, NONE, sshbug_oldgex2) \\r
843 X(INT, NONE, sshbug_winadj) \\r
844 X(INT, NONE, sshbug_chanreq) \\r
845 /* \\r
846 * ssh_simple means that we promise never to open any channel \\r
847 * other than the main one, which means it can safely use a very \\r
848 * large window in SSH-2. \\r
849 */ \\r
850 X(INT, NONE, ssh_simple) \\r
851 X(INT, NONE, ssh_connection_sharing) \\r
852 X(INT, NONE, ssh_connection_sharing_upstream) \\r
853 X(INT, NONE, ssh_connection_sharing_downstream) \\r
854 /*\r
855 * ssh_manual_hostkeys is conceptually a set rather than a\r
856 * dictionary: the string subkeys are the important thing, and the\r
857 * actual values to which those subkeys map are all "".\r
858 */ \\r
859 X(STR, STR, ssh_manual_hostkeys) \\r
860 /* Options for pterm. Should split out into platform-dependent part. */ \\r
861 X(INT, NONE, stamp_utmp) \\r
862 X(INT, NONE, login_shell) \\r
863 X(INT, NONE, scrollbar_on_left) \\r
864 X(INT, NONE, shadowbold) \\r
865 X(FONT, NONE, boldfont) \\r
866 X(FONT, NONE, widefont) \\r
867 X(FONT, NONE, wideboldfont) \\r
868 X(INT, NONE, shadowboldoffset) \\r
869 X(INT, NONE, crhaslf) \\r
870 X(STR, NONE, winclass) \\r
871 \r
872 /* Now define the actual enum of option keywords using that macro. */\r
873 #define CONF_ENUM_DEF(valtype, keytype, keyword) CONF_ ## keyword,\r
874 enum config_primary_key { CONFIG_OPTIONS(CONF_ENUM_DEF) N_CONFIG_OPTIONS };\r
875 #undef CONF_ENUM_DEF\r
876 \r
877 #define NCFGCOLOURS 22 /* number of colours in CONF_colours above */\r
878 \r
879 /* Functions handling configuration structures. */\r
880 Conf *conf_new(void); /* create an empty configuration */\r
881 void conf_free(Conf *conf);\r
882 Conf *conf_copy(Conf *oldconf);\r
883 void conf_copy_into(Conf *dest, Conf *src);\r
884 /* Mandatory accessor functions: enforce by assertion that keys exist. */\r
885 int conf_get_int(Conf *conf, int key);\r
886 int conf_get_int_int(Conf *conf, int key, int subkey);\r
887 char *conf_get_str(Conf *conf, int key); /* result still owned by conf */\r
888 char *conf_get_str_str(Conf *conf, int key, const char *subkey);\r
889 Filename *conf_get_filename(Conf *conf, int key);\r
890 FontSpec *conf_get_fontspec(Conf *conf, int key); /* still owned by conf */\r
891 /* Optional accessor function: return NULL if key does not exist. */\r
892 char *conf_get_str_str_opt(Conf *conf, int key, const char *subkey);\r
893 /* Accessor function to step through a string-subkeyed list.\r
894 * Returns the next subkey after the provided one, or the first if NULL.\r
895 * Returns NULL if there are none left.\r
896 * Both the return value and *subkeyout are still owned by conf. */\r
897 char *conf_get_str_strs(Conf *conf, int key, char *subkeyin, char **subkeyout);\r
898 /* Return the nth string subkey in a list. Owned by conf. NULL if beyond end */\r
899 char *conf_get_str_nthstrkey(Conf *conf, int key, int n);\r
900 /* Functions to set entries in configuration. Always copy their inputs. */\r
901 void conf_set_int(Conf *conf, int key, int value);\r
902 void conf_set_int_int(Conf *conf, int key, int subkey, int value);\r
903 void conf_set_str(Conf *conf, int key, const char *value);\r
904 void conf_set_str_str(Conf *conf, int key,\r
905 const char *subkey, const char *val);\r
906 void conf_del_str_str(Conf *conf, int key, const char *subkey);\r
907 void conf_set_filename(Conf *conf, int key, const Filename *val);\r
908 void conf_set_fontspec(Conf *conf, int key, const FontSpec *val);\r
909 /* Serialisation functions for Duplicate Session */\r
910 int conf_serialised_size(Conf *conf);\r
911 void conf_serialise(Conf *conf, void *data);\r
912 int conf_deserialise(Conf *conf, void *data, int maxsize);/*returns size used*/\r
913 \r
914 /*\r
915 * Functions to copy, free, serialise and deserialise FontSpecs.\r
916 * Provided per-platform, to go with the platform's idea of a\r
917 * FontSpec's contents.\r
918 *\r
919 * fontspec_serialise returns the number of bytes written, and can\r
920 * handle data==NULL without crashing. So you can call it once to find\r
921 * out a size, then again once you've allocated a buffer.\r
922 */\r
923 FontSpec *fontspec_copy(const FontSpec *f);\r
924 void fontspec_free(FontSpec *f);\r
925 int fontspec_serialise(FontSpec *f, void *data);\r
926 FontSpec *fontspec_deserialise(void *data, int maxsize, int *used);\r
927 \r
928 /*\r
929 * Exports from noise.c.\r
930 */\r
931 void noise_get_heavy(void (*func) (void *, int));\r
932 void noise_get_light(void (*func) (void *, int));\r
933 void noise_regular(void);\r
934 void noise_ultralight(unsigned long data);\r
935 void random_save_seed(void);\r
936 void random_destroy_seed(void);\r
937 \r
938 /*\r
939 * Exports from settings.c.\r
940 */\r
941 Backend *backend_from_name(const char *name);\r
942 Backend *backend_from_proto(int proto);\r
943 char *get_remote_username(Conf *conf); /* dynamically allocated */\r
944 char *save_settings(char *section, Conf *conf);\r
945 void save_open_settings(void *sesskey, Conf *conf);\r
946 void load_settings(char *section, Conf *conf);\r
947 void load_open_settings(void *sesskey, Conf *conf);\r
948 void get_sesslist(struct sesslist *, int allocate);\r
949 void do_defaults(char *, Conf *);\r
950 void registry_cleanup(void);\r
951 \r
952 /*\r
953 * Functions used by settings.c to provide platform-specific\r
954 * default settings.\r
955 * \r
956 * (The integer one is expected to return `def' if it has no clear\r
957 * opinion of its own. This is because there's no integer value\r
958 * which I can reliably set aside to indicate `nil'. The string\r
959 * function is perfectly all right returning NULL, of course. The\r
960 * Filename and FontSpec functions are _not allowed_ to fail to\r
961 * return, since these defaults _must_ be per-platform.)\r
962 *\r
963 * The 'Filename *' returned by platform_default_filename, and the\r
964 * 'FontSpec *' returned by platform_default_fontspec, have ownership\r
965 * transferred to the caller, and must be freed.\r
966 */\r
967 char *platform_default_s(const char *name);\r
968 int platform_default_i(const char *name, int def);\r
969 Filename *platform_default_filename(const char *name);\r
970 FontSpec *platform_default_fontspec(const char *name);\r
971 \r
972 /*\r
973 * Exports from terminal.c.\r
974 */\r
975 \r
976 Terminal *term_init(Conf *, struct unicode_data *, void *);\r
977 void term_free(Terminal *);\r
978 void term_size(Terminal *, int, int, int);\r
979 void term_paint(Terminal *, Context, int, int, int, int, int);\r
980 void term_scroll(Terminal *, int, int);\r
981 void term_scroll_to_selection(Terminal *, int);\r
982 void term_pwron(Terminal *, int);\r
983 void term_clrsb(Terminal *);\r
984 void term_mouse(Terminal *, Mouse_Button, Mouse_Button, Mouse_Action,\r
985 int,int,int,int,int);\r
986 void term_key(Terminal *, Key_Sym, wchar_t *, size_t, unsigned int,\r
987 unsigned int);\r
988 void term_deselect(Terminal *);\r
989 void term_update(Terminal *);\r
990 void term_invalidate(Terminal *);\r
991 void term_blink(Terminal *, int set_cursor);\r
992 void term_do_paste(Terminal *);\r
993 void term_nopaste(Terminal *);\r
994 int term_ldisc(Terminal *, int option);\r
995 void term_copyall(Terminal *);\r
996 void term_reconfig(Terminal *, Conf *);\r
997 void term_seen_key_event(Terminal *); \r
998 int term_data(Terminal *, int is_stderr, const char *data, int len);\r
999 int term_data_untrusted(Terminal *, const char *data, int len);\r
1000 void term_provide_resize_fn(Terminal *term,\r
1001 void (*resize_fn)(void *, int, int),\r
1002 void *resize_ctx);\r
1003 void term_provide_logctx(Terminal *term, void *logctx);\r
1004 void term_set_focus(Terminal *term, int has_focus);\r
1005 char *term_get_ttymode(Terminal *term, const char *mode);\r
1006 int term_get_userpass_input(Terminal *term, prompts_t *p,\r
1007 unsigned char *in, int inlen);\r
1008 \r
1009 int format_arrow_key(char *buf, Terminal *term, int xkey, int ctrl);\r
1010 \r
1011 /*\r
1012 * Exports from logging.c.\r
1013 */\r
1014 void *log_init(void *frontend, Conf *conf);\r
1015 void log_free(void *logctx);\r
1016 void log_reconfig(void *logctx, Conf *conf);\r
1017 void logfopen(void *logctx);\r
1018 void logfclose(void *logctx);\r
1019 void logtraffic(void *logctx, unsigned char c, int logmode);\r
1020 void logflush(void *logctx);\r
1021 void log_eventlog(void *logctx, const char *string);\r
1022 enum { PKT_INCOMING, PKT_OUTGOING };\r
1023 enum { PKTLOG_EMIT, PKTLOG_BLANK, PKTLOG_OMIT };\r
1024 struct logblank_t {\r
1025 int offset;\r
1026 int len;\r
1027 int type;\r
1028 };\r
1029 void log_packet(void *logctx, int direction, int type,\r
1030 char *texttype, const void *data, int len,\r
1031 int n_blanks, const struct logblank_t *blanks,\r
1032 const unsigned long *sequence,\r
1033 unsigned downstream_id, const char *additional_log_text);\r
1034 \r
1035 /*\r
1036 * Exports from testback.c\r
1037 */\r
1038 \r
1039 extern Backend null_backend;\r
1040 extern Backend loop_backend;\r
1041 \r
1042 /*\r
1043 * Exports from raw.c.\r
1044 */\r
1045 \r
1046 extern Backend raw_backend;\r
1047 \r
1048 /*\r
1049 * Exports from rlogin.c.\r
1050 */\r
1051 \r
1052 extern Backend rlogin_backend;\r
1053 \r
1054 /*\r
1055 * Exports from telnet.c.\r
1056 */\r
1057 \r
1058 extern Backend telnet_backend;\r
1059 \r
1060 /*\r
1061 * Exports from ssh.c.\r
1062 */\r
1063 extern Backend ssh_backend;\r
1064 \r
1065 /*\r
1066 * Exports from ldisc.c.\r
1067 */\r
1068 void *ldisc_create(Conf *, Terminal *, Backend *, void *, void *);\r
1069 void ldisc_configure(void *, Conf *);\r
1070 void ldisc_free(void *);\r
1071 void ldisc_send(void *handle, char *buf, int len, int interactive);\r
1072 \r
1073 /*\r
1074 * Exports from ldiscucs.c.\r
1075 */\r
1076 void lpage_send(void *, int codepage, char *buf, int len, int interactive);\r
1077 void luni_send(void *, wchar_t * widebuf, int len, int interactive);\r
1078 \r
1079 /*\r
1080 * Exports from sshrand.c.\r
1081 */\r
1082 \r
1083 void random_add_noise(void *noise, int length);\r
1084 int random_byte(void);\r
1085 void random_get_savedata(void **data, int *len);\r
1086 extern int random_active;\r
1087 /* The random number subsystem is activated if at least one other entity\r
1088 * within the program expresses an interest in it. So each SSH session\r
1089 * calls random_ref on startup and random_unref on shutdown. */\r
1090 void random_ref(void);\r
1091 void random_unref(void);\r
1092 \r
1093 /*\r
1094 * Exports from pinger.c.\r
1095 */\r
1096 typedef struct pinger_tag *Pinger;\r
1097 Pinger pinger_new(Conf *conf, Backend *back, void *backhandle);\r
1098 void pinger_reconfig(Pinger, Conf *oldconf, Conf *newconf);\r
1099 void pinger_free(Pinger);\r
1100 \r
1101 /*\r
1102 * Exports from misc.c.\r
1103 */\r
1104 \r
1105 #include "misc.h"\r
1106 int conf_launchable(Conf *conf);\r
1107 char const *conf_dest(Conf *conf);\r
1108 \r
1109 /*\r
1110 * Exports from sercfg.c.\r
1111 */\r
1112 void ser_setup_config_box(struct controlbox *b, int midsession,\r
1113 int parity_mask, int flow_mask);\r
1114 \r
1115 /*\r
1116 * Exports from version.c.\r
1117 */\r
1118 extern char ver[];\r
1119 \r
1120 /*\r
1121 * Exports from unicode.c.\r
1122 */\r
1123 #ifndef CP_UTF8\r
1124 #define CP_UTF8 65001\r
1125 #endif\r
1126 /* void init_ucs(void); -- this is now in platform-specific headers */\r
1127 int is_dbcs_leadbyte(int codepage, char byte);\r
1128 int mb_to_wc(int codepage, int flags, const char *mbstr, int mblen,\r
1129 wchar_t *wcstr, int wclen);\r
1130 int wc_to_mb(int codepage, int flags, const wchar_t *wcstr, int wclen,\r
1131 char *mbstr, int mblen, char *defchr, int *defused,\r
1132 struct unicode_data *ucsdata);\r
1133 wchar_t xlat_uskbd2cyrllic(int ch);\r
1134 int check_compose(int first, int second);\r
1135 int decode_codepage(char *cp_name);\r
1136 const char *cp_enumerate (int index);\r
1137 const char *cp_name(int codepage);\r
1138 void get_unitab(int codepage, wchar_t * unitab, int ftype);\r
1139 \r
1140 /*\r
1141 * Exports from wcwidth.c\r
1142 */\r
1143 int mk_wcwidth(unsigned int ucs);\r
1144 int mk_wcswidth(const unsigned int *pwcs, size_t n);\r
1145 int mk_wcwidth_cjk(unsigned int ucs);\r
1146 int mk_wcswidth_cjk(const unsigned int *pwcs, size_t n);\r
1147 \r
1148 /*\r
1149 * Exports from mscrypto.c\r
1150 */\r
1151 #ifdef MSCRYPTOAPI\r
1152 int crypto_startup();\r
1153 void crypto_wrapup();\r
1154 #endif\r
1155 \r
1156 /*\r
1157 * Exports from pageantc.c.\r
1158 * \r
1159 * agent_query returns 1 for here's-a-response, and 0 for query-in-\r
1160 * progress. In the latter case there will be a call to `callback'\r
1161 * at some future point, passing callback_ctx as the first\r
1162 * parameter and the actual reply data as the second and third.\r
1163 * \r
1164 * The response may be a NULL pointer (in either of the synchronous\r
1165 * or asynchronous cases), which indicates failure to receive a\r
1166 * response.\r
1167 */\r
1168 int agent_query(void *in, int inlen, void **out, int *outlen,\r
1169 void (*callback)(void *, void *, int), void *callback_ctx);\r
1170 int agent_exists(void);\r
1171 \r
1172 /*\r
1173 * Exports from wildcard.c\r
1174 */\r
1175 const char *wc_error(int value);\r
1176 int wc_match(const char *wildcard, const char *target);\r
1177 int wc_unescape(char *output, const char *wildcard);\r
1178 \r
1179 /*\r
1180 * Exports from frontend (windlg.c etc)\r
1181 */\r
1182 void logevent(void *frontend, const char *);\r
1183 void pgp_fingerprints(void);\r
1184 /*\r
1185 * verify_ssh_host_key() can return one of three values:\r
1186 * \r
1187 * - +1 means `key was OK' (either already known or the user just\r
1188 * approved it) `so continue with the connection'\r
1189 * \r
1190 * - 0 means `key was not OK, abandon the connection'\r
1191 * \r
1192 * - -1 means `I've initiated enquiries, please wait to be called\r
1193 * back via the provided function with a result that's either 0\r
1194 * or +1'.\r
1195 */\r
1196 int verify_ssh_host_key(void *frontend, char *host, int port, char *keytype,\r
1197 char *keystr, char *fingerprint,\r
1198 void (*callback)(void *ctx, int result), void *ctx);\r
1199 /*\r
1200 * askalg has the same set of return values as verify_ssh_host_key.\r
1201 */\r
1202 int askalg(void *frontend, const char *algtype, const char *algname,\r
1203 void (*callback)(void *ctx, int result), void *ctx);\r
1204 /*\r
1205 * askappend can return four values:\r
1206 * \r
1207 * - 2 means overwrite the log file\r
1208 * - 1 means append to the log file\r
1209 * - 0 means cancel logging for this session\r
1210 * - -1 means please wait.\r
1211 */\r
1212 int askappend(void *frontend, Filename *filename,\r
1213 void (*callback)(void *ctx, int result), void *ctx);\r
1214 \r
1215 /*\r
1216 * Exports from console frontends (wincons.c, uxcons.c)\r
1217 * that aren't equivalents to things in windlg.c et al.\r
1218 */\r
1219 extern int console_batch_mode;\r
1220 int console_get_userpass_input(prompts_t *p, unsigned char *in, int inlen);\r
1221 void console_provide_logctx(void *logctx);\r
1222 int is_interactive(void);\r
1223 \r
1224 /*\r
1225 * Exports from printing.c.\r
1226 */\r
1227 typedef struct printer_enum_tag printer_enum;\r
1228 typedef struct printer_job_tag printer_job;\r
1229 printer_enum *printer_start_enum(int *nprinters);\r
1230 char *printer_get_name(printer_enum *, int);\r
1231 void printer_finish_enum(printer_enum *);\r
1232 printer_job *printer_start_job(char *printer);\r
1233 void printer_job_data(printer_job *, void *, int);\r
1234 void printer_finish_job(printer_job *);\r
1235 \r
1236 /*\r
1237 * Exports from cmdline.c (and also cmdline_error(), which is\r
1238 * defined differently in various places and required _by_\r
1239 * cmdline.c).\r
1240 */\r
1241 int cmdline_process_param(char *, char *, int, Conf *);\r
1242 void cmdline_run_saved(Conf *);\r
1243 void cmdline_cleanup(void);\r
1244 int cmdline_get_passwd_input(prompts_t *p, unsigned char *in, int inlen);\r
1245 #define TOOLTYPE_FILETRANSFER 1\r
1246 #define TOOLTYPE_NONNETWORK 2\r
1247 extern int cmdline_tooltype;\r
1248 \r
1249 void cmdline_error(char *, ...);\r
1250 \r
1251 /*\r
1252 * Exports from config.c.\r
1253 */\r
1254 struct controlbox;\r
1255 union control;\r
1256 void conf_radiobutton_handler(union control *ctrl, void *dlg,\r
1257 void *data, int event);\r
1258 #define CHECKBOX_INVERT (1<<30)\r
1259 void conf_checkbox_handler(union control *ctrl, void *dlg,\r
1260 void *data, int event);\r
1261 void conf_editbox_handler(union control *ctrl, void *dlg,\r
1262 void *data, int event);\r
1263 void conf_filesel_handler(union control *ctrl, void *dlg,\r
1264 void *data, int event);\r
1265 void conf_fontsel_handler(union control *ctrl, void *dlg,\r
1266 void *data, int event);\r
1267 void setup_config_box(struct controlbox *b, int midsession,\r
1268 int protocol, int protcfginfo);\r
1269 \r
1270 /*\r
1271 * Exports from minibidi.c.\r
1272 */\r
1273 typedef struct bidi_char {\r
1274 unsigned int origwc, wc;\r
1275 unsigned short index;\r
1276 } bidi_char;\r
1277 int do_bidi(bidi_char *line, int count);\r
1278 int do_shape(bidi_char *line, bidi_char *to, int count);\r
1279 int is_rtl(int c);\r
1280 \r
1281 /*\r
1282 * X11 auth mechanisms we know about.\r
1283 */\r
1284 enum {\r
1285 X11_NO_AUTH,\r
1286 X11_MIT, /* MIT-MAGIC-COOKIE-1 */\r
1287 X11_XDM, /* XDM-AUTHORIZATION-1 */\r
1288 X11_NAUTHS\r
1289 };\r
1290 extern const char *const x11_authnames[]; /* declared in x11fwd.c */\r
1291 \r
1292 /*\r
1293 * Miscellaneous exports from the platform-specific code.\r
1294 *\r
1295 * filename_serialise and filename_deserialise have the same semantics\r
1296 * as fontspec_serialise and fontspec_deserialise above.\r
1297 */\r
1298 Filename *filename_from_str(const char *string);\r
1299 const char *filename_to_str(const Filename *fn);\r
1300 int filename_equal(const Filename *f1, const Filename *f2);\r
1301 int filename_is_null(const Filename *fn);\r
1302 Filename *filename_copy(const Filename *fn);\r
1303 void filename_free(Filename *fn);\r
1304 int filename_serialise(const Filename *f, void *data);\r
1305 Filename *filename_deserialise(void *data, int maxsize, int *used);\r
1306 char *get_username(void); /* return value needs freeing */\r
1307 char *get_random_data(int bytes); /* used in cmdgen.c */\r
1308 char filename_char_sanitise(char c); /* rewrite special pathname chars */\r
1309 \r
1310 /*\r
1311 * Exports and imports from timing.c.\r
1312 *\r
1313 * schedule_timer() asks the front end to schedule a callback to a\r
1314 * timer function in a given number of ticks. The returned value is\r
1315 * the time (in ticks since an arbitrary offset) at which the\r
1316 * callback can be expected. This value will also be passed as the\r
1317 * `now' parameter to the callback function. Hence, you can (for\r
1318 * example) schedule an event at a particular time by calling\r
1319 * schedule_timer() and storing the return value in your context\r
1320 * structure as the time when that event is due. The first time a\r
1321 * callback function gives you that value or more as `now', you do\r
1322 * the thing.\r
1323 * \r
1324 * expire_timer_context() drops all current timers associated with\r
1325 * a given value of ctx (for when you're about to free ctx).\r
1326 * \r
1327 * run_timers() is called from the front end when it has reason to\r
1328 * think some timers have reached their moment, or when it simply\r
1329 * needs to know how long to wait next. We pass it the time we\r
1330 * think it is. It returns TRUE and places the time when the next\r
1331 * timer needs to go off in `next', or alternatively it returns\r
1332 * FALSE if there are no timers at all pending.\r
1333 * \r
1334 * timer_change_notify() must be supplied by the front end; it\r
1335 * notifies the front end that a new timer has been added to the\r
1336 * list which is sooner than any existing ones. It provides the\r
1337 * time when that timer needs to go off.\r
1338 * \r
1339 * *** FRONT END IMPLEMENTORS NOTE:\r
1340 * \r
1341 * There's an important subtlety in the front-end implementation of\r
1342 * the timer interface. When a front end is given a `next' value,\r
1343 * either returned from run_timers() or via timer_change_notify(),\r
1344 * it should ensure that it really passes _that value_ as the `now'\r
1345 * parameter to its next run_timers call. It should _not_ simply\r
1346 * call GETTICKCOUNT() to get the `now' parameter when invoking\r
1347 * run_timers().\r
1348 * \r
1349 * The reason for this is that an OS's system clock might not agree\r
1350 * exactly with the timing mechanisms it supplies to wait for a\r
1351 * given interval. I'll illustrate this by the simple example of\r
1352 * Unix Plink, which uses timeouts to select() in a way which for\r
1353 * these purposes can simply be considered to be a wait() function.\r
1354 * Suppose, for the sake of argument, that this wait() function\r
1355 * tends to return early by 1%. Then a possible sequence of actions\r
1356 * is:\r
1357 * \r
1358 * - run_timers() tells the front end that the next timer firing\r
1359 * is 10000ms from now.\r
1360 * - Front end calls wait(10000ms), but according to\r
1361 * GETTICKCOUNT() it has only waited for 9900ms.\r
1362 * - Front end calls run_timers() again, passing time T-100ms as\r
1363 * `now'.\r
1364 * - run_timers() does nothing, and says the next timer firing is\r
1365 * still 100ms from now.\r
1366 * - Front end calls wait(100ms), which only waits for 99ms.\r
1367 * - Front end calls run_timers() yet again, passing time T-1ms.\r
1368 * - run_timers() says there's still 1ms to wait.\r
1369 * - Front end calls wait(1ms).\r
1370 * \r
1371 * If you're _lucky_ at this point, wait(1ms) will actually wait\r
1372 * for 1ms and you'll only have woken the program up three times.\r
1373 * If you're unlucky, wait(1ms) might do nothing at all due to\r
1374 * being below some minimum threshold, and you might find your\r
1375 * program spends the whole of the last millisecond tight-looping\r
1376 * between wait() and run_timers().\r
1377 * \r
1378 * Instead, what you should do is to _save_ the precise `next'\r
1379 * value provided by run_timers() or via timer_change_notify(), and\r
1380 * use that precise value as the input to the next run_timers()\r
1381 * call. So:\r
1382 * \r
1383 * - run_timers() tells the front end that the next timer firing\r
1384 * is at time T, 10000ms from now.\r
1385 * - Front end calls wait(10000ms).\r
1386 * - Front end then immediately calls run_timers() and passes it\r
1387 * time T, without stopping to check GETTICKCOUNT() at all.\r
1388 * \r
1389 * This guarantees that the program wakes up only as many times as\r
1390 * there are actual timer actions to be taken, and that the timing\r
1391 * mechanism will never send it into a tight loop.\r
1392 * \r
1393 * (It does also mean that the timer action in the above example\r
1394 * will occur 100ms early, but this is not generally critical. And\r
1395 * the hypothetical 1% error in wait() will be partially corrected\r
1396 * for anyway when, _after_ run_timers() returns, you call\r
1397 * GETTICKCOUNT() and compare the result with the returned `next'\r
1398 * value to find out how long you have to make your next wait().)\r
1399 */\r
1400 typedef void (*timer_fn_t)(void *ctx, unsigned long now);\r
1401 unsigned long schedule_timer(int ticks, timer_fn_t fn, void *ctx);\r
1402 void expire_timer_context(void *ctx);\r
1403 int run_timers(unsigned long now, unsigned long *next);\r
1404 void timer_change_notify(unsigned long next);\r
1405 \r
1406 /*\r
1407 * Exports from callback.c.\r
1408 *\r
1409 * This provides a method of queuing function calls to be run at the\r
1410 * earliest convenience from the top-level event loop. Use it if\r
1411 * you're deep in a nested chain of calls and want to trigger an\r
1412 * action which will probably lead to your function being re-entered\r
1413 * recursively if you just call the initiating function the normal\r
1414 * way.\r
1415 *\r
1416 * Most front ends run the queued callbacks by simply calling\r
1417 * run_toplevel_callbacks() after handling each event in their\r
1418 * top-level event loop. However, if a front end doesn't have control\r
1419 * over its own event loop (e.g. because it's using GTK) then it can\r
1420 * instead request notifications when a callback is available, so that\r
1421 * it knows to ask its delegate event loop to do the same thing. Also,\r
1422 * if a front end needs to know whether a callback is pending without\r
1423 * actually running it (e.g. so as to put a zero timeout on a select()\r
1424 * call) then it can call toplevel_callback_pending(), which will\r
1425 * return true if at least one callback is in the queue.\r
1426 */\r
1427 typedef void (*toplevel_callback_fn_t)(void *ctx);\r
1428 void queue_toplevel_callback(toplevel_callback_fn_t fn, void *ctx);\r
1429 void run_toplevel_callbacks(void);\r
1430 int toplevel_callback_pending(void);\r
1431 \r
1432 typedef void (*toplevel_callback_notify_fn_t)(void *frontend);\r
1433 void request_callback_notifications(toplevel_callback_notify_fn_t notify,\r
1434 void *frontend);\r
1435 \r
1436 /*\r
1437 * Define no-op macros for the jump list functions, on platforms that\r
1438 * don't support them. (This is a bit of a hack, and it'd be nicer to\r
1439 * localise even the calls to those functions into the Windows front\r
1440 * end, but it'll do for the moment.)\r
1441 */\r
1442 #ifndef JUMPLIST_SUPPORTED\r
1443 #define add_session_to_jumplist(x) ((void)0)\r
1444 #define remove_session_from_jumplist(x) ((void)0)\r
1445 #endif\r
1446 \r
1447 /* SURROGATE PAIR */\r
1448 #define HIGH_SURROGATE_START 0xd800\r
1449 #define HIGH_SURROGATE_END 0xdbff\r
1450 #define LOW_SURROGATE_START 0xdc00\r
1451 #define LOW_SURROGATE_END 0xdfff\r
1452 \r
1453 /* These macros exist in the Windows API, so the environment may\r
1454 * provide them. If not, define them in terms of the above. */\r
1455 #ifndef IS_HIGH_SURROGATE\r
1456 #define IS_HIGH_SURROGATE(wch) (((wch) >= HIGH_SURROGATE_START) && \\r
1457 ((wch) <= HIGH_SURROGATE_END))\r
1458 #define IS_LOW_SURROGATE(wch) (((wch) >= LOW_SURROGATE_START) && \\r
1459 ((wch) <= LOW_SURROGATE_END))\r
1460 #define IS_SURROGATE_PAIR(hs, ls) (IS_HIGH_SURROGATE(hs) && \\r
1461 IS_LOW_SURROGATE(ls))\r
1462 #endif\r
1463 \r
1464 \r
1465 #define IS_SURROGATE(wch) (((wch) >= HIGH_SURROGATE_START) && \\r
1466 ((wch) <= LOW_SURROGATE_END))\r
1467 #define HIGH_SURROGATE_OF(codept) \\r
1468 (HIGH_SURROGATE_START + (((codept) - 0x10000) >> 10))\r
1469 #define LOW_SURROGATE_OF(codept) \\r
1470 (LOW_SURROGATE_START + (((codept) - 0x10000) & 0x3FF))\r
1471 #define FROM_SURROGATES(wch1, wch2) \\r
1472 (0x10000 + (((wch1) & 0x3FF) << 10) + ((wch2) & 0x3FF))\r
1473 \r
1474 #endif\r