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