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