projects / u / mdw / putty / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Implement my experimental arcfour modes. The 256-bit version is disabled
[u/mdw/putty] / config.c
1 /*
2 * config.c - the platform-independent parts of the PuTTY
3 * configuration box.
4 */
5
6 #include <assert.h>
7 #include <stdlib.h>
8
9 #include "putty.h"
10 #include "dialog.h"
11 #include "storage.h"
12
13 #define PRINTER_DISABLED_STRING "None (printing disabled)"
14
15 static void protocolbuttons_handler(union control *ctrl, void *dlg,
16 void *data, int event)
17 {
18 int button, defport;
19 Config *cfg = (Config *)data;
20 /*
21 * This function works just like the standard radio-button
22 * handler, except that it also has to change the setting of
23 * the port box. We expect the context parameter to point at
24 * the `union control' structure for the port box.
25 */
26 if (event == EVENT_REFRESH) {
27 for (button = 0; button < ctrl->radio.nbuttons; button++)
28 if (cfg->protocol == ctrl->radio.buttondata[button].i)
29 break;
30 /* We expected that `break' to happen, in all circumstances. */
31 assert(button < ctrl->radio.nbuttons);
32 dlg_radiobutton_set(ctrl, dlg, button);
33 } else if (event == EVENT_VALCHANGE) {
34 int oldproto = cfg->protocol;
35 button = dlg_radiobutton_get(ctrl, dlg);
36 assert(button >= 0 && button < ctrl->radio.nbuttons);
37 cfg->protocol = ctrl->radio.buttondata[button].i;
38 if (oldproto != cfg->protocol) {
39 defport = -1;
40 switch (cfg->protocol) {
41 case PROT_SSH: defport = 22; break;
42 case PROT_TELNET: defport = 23; break;
43 case PROT_RLOGIN: defport = 513; break;
44 }
45 if (defport > 0 && cfg->port != defport) {
46 cfg->port = defport;
47 dlg_refresh((union control *)ctrl->radio.context.p, dlg);
48 }
49 }
50 }
51 }
52
53 static void loggingbuttons_handler(union control *ctrl, void *dlg,
54 void *data, int event)
55 {
56 int button;
57 Config *cfg = (Config *)data;
58 /* This function works just like the standard radio-button handler,
59 * but it has to fall back to "no logging" in situations where the
60 * configured logging type isn't applicable.
61 */
62 if (event == EVENT_REFRESH) {
63 for (button = 0; button < ctrl->radio.nbuttons; button++)
64 if (cfg->logtype == ctrl->radio.buttondata[button].i)
65 break;
66
67 /* We fell off the end, so we lack the configured logging type */
68 if (button == ctrl->radio.nbuttons) {
69 button=0;
70 cfg->logtype=LGTYP_NONE;
71 }
72 dlg_radiobutton_set(ctrl, dlg, button);
73 } else if (event == EVENT_VALCHANGE) {
74 button = dlg_radiobutton_get(ctrl, dlg);
75 assert(button >= 0 && button < ctrl->radio.nbuttons);
76 cfg->logtype = ctrl->radio.buttondata[button].i;
77 }
78 }
79
80 static void numeric_keypad_handler(union control *ctrl, void *dlg,
81 void *data, int event)
82 {
83 int button;
84 Config *cfg = (Config *)data;
85 /*
86 * This function works much like the standard radio button
87 * handler, but it has to handle two fields in Config.
88 */
89 if (event == EVENT_REFRESH) {
90 if (cfg->nethack_keypad)
91 button = 2;
92 else if (cfg->app_keypad)
93 button = 1;
94 else
95 button = 0;
96 assert(button < ctrl->radio.nbuttons);
97 dlg_radiobutton_set(ctrl, dlg, button);
98 } else if (event == EVENT_VALCHANGE) {
99 button = dlg_radiobutton_get(ctrl, dlg);
100 assert(button >= 0 && button < ctrl->radio.nbuttons);
101 if (button == 2) {
102 cfg->app_keypad = FALSE;
103 cfg->nethack_keypad = TRUE;
104 } else {
105 cfg->app_keypad = (button != 0);
106 cfg->nethack_keypad = FALSE;
107 }
108 }
109 }
110
111 static void cipherlist_handler(union control *ctrl, void *dlg,
112 void *data, int event)
113 {
114 Config *cfg = (Config *)data;
115 if (event == EVENT_REFRESH) {
116 int i;
117
118 static const struct { char *s; int c; } ciphers[] = {
119 { "3DES", CIPHER_3DES },
120 { "Blowfish", CIPHER_BLOWFISH },
121 { "DES", CIPHER_DES },
122 { "AES (SSH-2 only)", CIPHER_AES },
123 { "Arcfour (SSH-2 only)", CIPHER_ARCFOUR },
124 { "-- warn below here --", CIPHER_WARN }
125 };
126
127 /* Set up the "selected ciphers" box. */
128 /* (cipherlist assumed to contain all ciphers) */
129 dlg_update_start(ctrl, dlg);
130 dlg_listbox_clear(ctrl, dlg);
131 for (i = 0; i < CIPHER_MAX; i++) {
132 int c = cfg->ssh_cipherlist[i];
133 int j;
134 char *cstr = NULL;
135 for (j = 0; j < (sizeof ciphers) / (sizeof ciphers[0]); j++) {
136 if (ciphers[j].c == c) {
137 cstr = ciphers[j].s;
138 break;
139 }
140 }
141 dlg_listbox_addwithid(ctrl, dlg, cstr, c);
142 }
143 dlg_update_done(ctrl, dlg);
144
145 } else if (event == EVENT_VALCHANGE) {
146 int i;
147
148 /* Update array to match the list box. */
149 for (i=0; i < CIPHER_MAX; i++)
150 cfg->ssh_cipherlist[i] = dlg_listbox_getid(ctrl, dlg, i);
151
152 }
153 }
154
155 static void kexlist_handler(union control *ctrl, void *dlg,
156 void *data, int event)
157 {
158 Config *cfg = (Config *)data;
159 if (event == EVENT_REFRESH) {
160 int i;
161
162 static const struct { char *s; int k; } kexes[] = {
163 { "Diffie-Hellman group 1", KEX_DHGROUP1 },
164 { "Diffie-Hellman group 14", KEX_DHGROUP14 },
165 { "Diffie-Hellman group exchange", KEX_DHGEX },
166 { "-- warn below here --", KEX_WARN }
167 };
168
169 /* Set up the "kex preference" box. */
170 /* (kexlist assumed to contain all algorithms) */
171 dlg_update_start(ctrl, dlg);
172 dlg_listbox_clear(ctrl, dlg);
173 for (i = 0; i < KEX_MAX; i++) {
174 int k = cfg->ssh_kexlist[i];
175 int j;
176 char *kstr = NULL;
177 for (j = 0; j < (sizeof kexes) / (sizeof kexes[0]); j++) {
178 if (kexes[j].k == k) {
179 kstr = kexes[j].s;
180 break;
181 }
182 }
183 dlg_listbox_addwithid(ctrl, dlg, kstr, k);
184 }
185 dlg_update_done(ctrl, dlg);
186
187 } else if (event == EVENT_VALCHANGE) {
188 int i;
189
190 /* Update array to match the list box. */
191 for (i=0; i < KEX_MAX; i++)
192 cfg->ssh_kexlist[i] = dlg_listbox_getid(ctrl, dlg, i);
193
194 }
195 }
196
197 static void printerbox_handler(union control *ctrl, void *dlg,
198 void *data, int event)
199 {
200 Config *cfg = (Config *)data;
201 if (event == EVENT_REFRESH) {
202 int nprinters, i;
203 printer_enum *pe;
204
205 dlg_update_start(ctrl, dlg);
206 /*
207 * Some backends may wish to disable the drop-down list on
208 * this edit box. Be prepared for this.
209 */
210 if (ctrl->editbox.has_list) {
211 dlg_listbox_clear(ctrl, dlg);
212 dlg_listbox_add(ctrl, dlg, PRINTER_DISABLED_STRING);
213 pe = printer_start_enum(&nprinters);
214 for (i = 0; i < nprinters; i++)
215 dlg_listbox_add(ctrl, dlg, printer_get_name(pe, i));
216 printer_finish_enum(pe);
217 }
218 dlg_editbox_set(ctrl, dlg,
219 (*cfg->printer ? cfg->printer :
220 PRINTER_DISABLED_STRING));
221 dlg_update_done(ctrl, dlg);
222 } else if (event == EVENT_VALCHANGE) {
223 dlg_editbox_get(ctrl, dlg, cfg->printer, sizeof(cfg->printer));
224 if (!strcmp(cfg->printer, PRINTER_DISABLED_STRING))
225 *cfg->printer = '\0';
226 }
227 }
228
229 static void codepage_handler(union control *ctrl, void *dlg,
230 void *data, int event)
231 {
232 Config *cfg = (Config *)data;
233 if (event == EVENT_REFRESH) {
234 int i;
235 const char *cp;
236 dlg_update_start(ctrl, dlg);
237 strcpy(cfg->line_codepage,
238 cp_name(decode_codepage(cfg->line_codepage)));
239 dlg_listbox_clear(ctrl, dlg);
240 for (i = 0; (cp = cp_enumerate(i)) != NULL; i++)
241 dlg_listbox_add(ctrl, dlg, cp);
242 dlg_editbox_set(ctrl, dlg, cfg->line_codepage);
243 dlg_update_done(ctrl, dlg);
244 } else if (event == EVENT_VALCHANGE) {
245 dlg_editbox_get(ctrl, dlg, cfg->line_codepage,
246 sizeof(cfg->line_codepage));
247 strcpy(cfg->line_codepage,
248 cp_name(decode_codepage(cfg->line_codepage)));
249 }
250 }
251
252 static void sshbug_handler(union control *ctrl, void *dlg,
253 void *data, int event)
254 {
255 if (event == EVENT_REFRESH) {
256 dlg_update_start(ctrl, dlg);
257 dlg_listbox_clear(ctrl, dlg);
258 dlg_listbox_addwithid(ctrl, dlg, "Auto", AUTO);
259 dlg_listbox_addwithid(ctrl, dlg, "Off", FORCE_OFF);
260 dlg_listbox_addwithid(ctrl, dlg, "On", FORCE_ON);
261 switch (*(int *)ATOFFSET(data, ctrl->listbox.context.i)) {
262 case AUTO: dlg_listbox_select(ctrl, dlg, 0); break;
263 case FORCE_OFF: dlg_listbox_select(ctrl, dlg, 1); break;
264 case FORCE_ON: dlg_listbox_select(ctrl, dlg, 2); break;
265 }
266 dlg_update_done(ctrl, dlg);
267 } else if (event == EVENT_SELCHANGE) {
268 int i = dlg_listbox_index(ctrl, dlg);
269 if (i < 0)
270 i = AUTO;
271 else
272 i = dlg_listbox_getid(ctrl, dlg, i);
273 *(int *)ATOFFSET(data, ctrl->listbox.context.i) = i;
274 }
275 }
276
277 #define SAVEDSESSION_LEN 2048
278
279 struct sessionsaver_data {
280 union control *editbox, *listbox, *loadbutton, *savebutton, *delbutton;
281 union control *okbutton, *cancelbutton;
282 struct sesslist sesslist;
283 int midsession;
284 };
285
286 /*
287 * Helper function to load the session selected in the list box, if
288 * any, as this is done in more than one place below. Returns 0 for
289 * failure.
290 */
291 static int load_selected_session(struct sessionsaver_data *ssd,
292 char *savedsession,
293 void *dlg, Config *cfg)
294 {
295 int i = dlg_listbox_index(ssd->listbox, dlg);
296 int isdef;
297 if (i < 0) {
298 dlg_beep(dlg);
299 return 0;
300 }
301 isdef = !strcmp(ssd->sesslist.sessions[i], "Default Settings");
302 load_settings(ssd->sesslist.sessions[i], !isdef, cfg);
303 if (!isdef) {
304 strncpy(savedsession, ssd->sesslist.sessions[i],
305 SAVEDSESSION_LEN);
306 savedsession[SAVEDSESSION_LEN-1] = '\0';
307 } else {
308 savedsession[0] = '\0';
309 }
310 dlg_refresh(NULL, dlg);
311 /* Restore the selection, which might have been clobbered by
312 * changing the value of the edit box. */
313 dlg_listbox_select(ssd->listbox, dlg, i);
314 return 1;
315 }
316
317 static void sessionsaver_handler(union control *ctrl, void *dlg,
318 void *data, int event)
319 {
320 Config *cfg = (Config *)data;
321 struct sessionsaver_data *ssd =
322 (struct sessionsaver_data *)ctrl->generic.context.p;
323 char *savedsession;
324
325 /*
326 * The first time we're called in a new dialog, we must
327 * allocate space to store the current contents of the saved
328 * session edit box (since it must persist even when we switch
329 * panels, but is not part of the Config).
330 */
331 if (!ssd->editbox) {
332 savedsession = NULL;
333 } else if (!dlg_get_privdata(ssd->editbox, dlg)) {
334 savedsession = (char *)
335 dlg_alloc_privdata(ssd->editbox, dlg, SAVEDSESSION_LEN);
336 savedsession[0] = '\0';
337 } else {
338 savedsession = dlg_get_privdata(ssd->editbox, dlg);
339 }
340
341 if (event == EVENT_REFRESH) {
342 if (ctrl == ssd->editbox) {
343 dlg_editbox_set(ctrl, dlg, savedsession);
344 } else if (ctrl == ssd->listbox) {
345 int i;
346 dlg_update_start(ctrl, dlg);
347 dlg_listbox_clear(ctrl, dlg);
348 for (i = 0; i < ssd->sesslist.nsessions; i++)
349 dlg_listbox_add(ctrl, dlg, ssd->sesslist.sessions[i]);
350 dlg_update_done(ctrl, dlg);
351 }
352 } else if (event == EVENT_VALCHANGE) {
353 if (ctrl == ssd->editbox) {
354 dlg_editbox_get(ctrl, dlg, savedsession,
355 SAVEDSESSION_LEN);
356 }
357 } else if (event == EVENT_ACTION) {
358 if (!ssd->midsession &&
359 (ctrl == ssd->listbox ||
360 (ssd->loadbutton && ctrl == ssd->loadbutton))) {
361 /*
362 * The user has double-clicked a session, or hit Load.
363 * We must load the selected session, and then
364 * terminate the configuration dialog _if_ there was a
365 * double-click on the list box _and_ that session
366 * contains a hostname.
367 */
368 if (load_selected_session(ssd, savedsession, dlg, cfg) &&
369 (ctrl == ssd->listbox && cfg->host[0])) {
370 dlg_end(dlg, 1); /* it's all over, and succeeded */
371 }
372 } else if (ctrl == ssd->savebutton) {
373 int isdef = !strcmp(savedsession, "Default Settings");
374 if (!savedsession[0]) {
375 int i = dlg_listbox_index(ssd->listbox, dlg);
376 if (i < 0) {
377 dlg_beep(dlg);
378 return;
379 }
380 isdef = !strcmp(ssd->sesslist.sessions[i], "Default Settings");
381 if (!isdef) {
382 strncpy(savedsession, ssd->sesslist.sessions[i],
383 SAVEDSESSION_LEN);
384 savedsession[SAVEDSESSION_LEN-1] = '\0';
385 } else {
386 savedsession[0] = '\0';
387 }
388 }
389 {
390 char *errmsg = save_settings(savedsession, !isdef, cfg);
391 if (errmsg) {
392 dlg_error_msg(dlg, errmsg);
393 sfree(errmsg);
394 }
395 }
396 get_sesslist(&ssd->sesslist, FALSE);
397 get_sesslist(&ssd->sesslist, TRUE);
398 dlg_refresh(ssd->editbox, dlg);
399 dlg_refresh(ssd->listbox, dlg);
400 } else if (!ssd->midsession &&
401 ssd->delbutton && ctrl == ssd->delbutton) {
402 int i = dlg_listbox_index(ssd->listbox, dlg);
403 if (i <= 0) {
404 dlg_beep(dlg);
405 } else {
406 del_settings(ssd->sesslist.sessions[i]);
407 get_sesslist(&ssd->sesslist, FALSE);
408 get_sesslist(&ssd->sesslist, TRUE);
409 dlg_refresh(ssd->listbox, dlg);
410 }
411 } else if (ctrl == ssd->okbutton) {
412 if (ssd->midsession) {
413 /* In a mid-session Change Settings, Apply is always OK. */
414 dlg_end(dlg, 1);
415 return;
416 }
417 /*
418 * Annoying special case. If the `Open' button is
419 * pressed while no host name is currently set, _and_
420 * the session list previously had the focus, _and_
421 * there was a session selected in that which had a
422 * valid host name in it, then load it and go.
423 */
424 if (dlg_last_focused(ctrl, dlg) == ssd->listbox && !*cfg->host) {
425 Config cfg2;
426 if (!load_selected_session(ssd, savedsession, dlg, &cfg2)) {
427 dlg_beep(dlg);
428 return;
429 }
430 /* If at this point we have a valid session, go! */
431 if (*cfg2.host) {
432 *cfg = cfg2; /* structure copy */
433 cfg->remote_cmd_ptr = NULL;
434 dlg_end(dlg, 1);
435 } else
436 dlg_beep(dlg);
437 return;
438 }
439
440 /*
441 * Otherwise, do the normal thing: if we have a valid
442 * session, get going.
443 */
444 if (*cfg->host) {
445 dlg_end(dlg, 1);
446 } else
447 dlg_beep(dlg);
448 } else if (ctrl == ssd->cancelbutton) {
449 dlg_end(dlg, 0);
450 }
451 }
452 }
453
454 struct charclass_data {
455 union control *listbox, *editbox, *button;
456 };
457
458 static void charclass_handler(union control *ctrl, void *dlg,
459 void *data, int event)
460 {
461 Config *cfg = (Config *)data;
462 struct charclass_data *ccd =
463 (struct charclass_data *)ctrl->generic.context.p;
464
465 if (event == EVENT_REFRESH) {
466 if (ctrl == ccd->listbox) {
467 int i;
468 dlg_update_start(ctrl, dlg);
469 dlg_listbox_clear(ctrl, dlg);
470 for (i = 0; i < 128; i++) {
471 char str[100];
472 sprintf(str, "%d\t(0x%02X)\t%c\t%d", i, i,
473 (i >= 0x21 && i != 0x7F) ? i : ' ', cfg->wordness[i]);
474 dlg_listbox_add(ctrl, dlg, str);
475 }
476 dlg_update_done(ctrl, dlg);
477 }
478 } else if (event == EVENT_ACTION) {
479 if (ctrl == ccd->button) {
480 char str[100];
481 int i, n;
482 dlg_editbox_get(ccd->editbox, dlg, str, sizeof(str));
483 n = atoi(str);
484 for (i = 0; i < 128; i++) {
485 if (dlg_listbox_issel(ccd->listbox, dlg, i))
486 cfg->wordness[i] = n;
487 }
488 dlg_refresh(ccd->listbox, dlg);
489 }
490 }
491 }
492
493 struct colour_data {
494 union control *listbox, *redit, *gedit, *bedit, *button;
495 };
496
497 static const char *const colours[] = {
498 "Default Foreground", "Default Bold Foreground",
499 "Default Background", "Default Bold Background",
500 "Cursor Text", "Cursor Colour",
501 "ANSI Black", "ANSI Black Bold",
502 "ANSI Red", "ANSI Red Bold",
503 "ANSI Green", "ANSI Green Bold",
504 "ANSI Yellow", "ANSI Yellow Bold",
505 "ANSI Blue", "ANSI Blue Bold",
506 "ANSI Magenta", "ANSI Magenta Bold",
507 "ANSI Cyan", "ANSI Cyan Bold",
508 "ANSI White", "ANSI White Bold"
509 };
510
511 static void colour_handler(union control *ctrl, void *dlg,
512 void *data, int event)
513 {
514 Config *cfg = (Config *)data;
515 struct colour_data *cd =
516 (struct colour_data *)ctrl->generic.context.p;
517 int update = FALSE, r, g, b;
518
519 if (event == EVENT_REFRESH) {
520 if (ctrl == cd->listbox) {
521 int i;
522 dlg_update_start(ctrl, dlg);
523 dlg_listbox_clear(ctrl, dlg);
524 for (i = 0; i < lenof(colours); i++)
525 dlg_listbox_add(ctrl, dlg, colours[i]);
526 dlg_update_done(ctrl, dlg);
527 dlg_editbox_set(cd->redit, dlg, "");
528 dlg_editbox_set(cd->gedit, dlg, "");
529 dlg_editbox_set(cd->bedit, dlg, "");
530 }
531 } else if (event == EVENT_SELCHANGE) {
532 if (ctrl == cd->listbox) {
533 /* The user has selected a colour. Update the RGB text. */
534 int i = dlg_listbox_index(ctrl, dlg);
535 if (i < 0) {
536 dlg_beep(dlg);
537 return;
538 }
539 r = cfg->colours[i][0];
540 g = cfg->colours[i][1];
541 b = cfg->colours[i][2];
542 update = TRUE;
543 }
544 } else if (event == EVENT_VALCHANGE) {
545 if (ctrl == cd->redit || ctrl == cd->gedit || ctrl == cd->bedit) {
546 /* The user has changed the colour using the edit boxes. */
547 char buf[80];
548 int i, cval;
549
550 dlg_editbox_get(ctrl, dlg, buf, lenof(buf));
551 cval = atoi(buf) & 255;
552
553 i = dlg_listbox_index(cd->listbox, dlg);
554 if (i >= 0) {
555 if (ctrl == cd->redit)
556 cfg->colours[i][0] = cval;
557 else if (ctrl == cd->gedit)
558 cfg->colours[i][1] = cval;
559 else if (ctrl == cd->bedit)
560 cfg->colours[i][2] = cval;
561 }
562 }
563 } else if (event == EVENT_ACTION) {
564 if (ctrl == cd->button) {
565 int i = dlg_listbox_index(cd->listbox, dlg);
566 if (i < 0) {
567 dlg_beep(dlg);
568 return;
569 }
570 /*
571 * Start a colour selector, which will send us an
572 * EVENT_CALLBACK when it's finished and allow us to
573 * pick up the results.
574 */
575 dlg_coloursel_start(ctrl, dlg,
576 cfg->colours[i][0],
577 cfg->colours[i][1],
578 cfg->colours[i][2]);
579 }
580 } else if (event == EVENT_CALLBACK) {
581 if (ctrl == cd->button) {
582 int i = dlg_listbox_index(cd->listbox, dlg);
583 /*
584 * Collect the results of the colour selector. Will
585 * return nonzero on success, or zero if the colour
586 * selector did nothing (user hit Cancel, for example).
587 */
588 if (dlg_coloursel_results(ctrl, dlg, &r, &g, &b)) {
589 cfg->colours[i][0] = r;
590 cfg->colours[i][1] = g;
591 cfg->colours[i][2] = b;
592 update = TRUE;
593 }
594 }
595 }
596
597 if (update) {
598 char buf[40];
599 sprintf(buf, "%d", r); dlg_editbox_set(cd->redit, dlg, buf);
600 sprintf(buf, "%d", g); dlg_editbox_set(cd->gedit, dlg, buf);
601 sprintf(buf, "%d", b); dlg_editbox_set(cd->bedit, dlg, buf);
602 }
603 }
604
605 struct environ_data {
606 union control *varbox, *valbox, *addbutton, *rembutton, *listbox;
607 };
608
609 static void environ_handler(union control *ctrl, void *dlg,
610 void *data, int event)
611 {
612 Config *cfg = (Config *)data;
613 struct environ_data *ed =
614 (struct environ_data *)ctrl->generic.context.p;
615
616 if (event == EVENT_REFRESH) {
617 if (ctrl == ed->listbox) {
618 char *p = cfg->environmt;
619 dlg_update_start(ctrl, dlg);
620 dlg_listbox_clear(ctrl, dlg);
621 while (*p) {
622 dlg_listbox_add(ctrl, dlg, p);
623 p += strlen(p) + 1;
624 }
625 dlg_update_done(ctrl, dlg);
626 }
627 } else if (event == EVENT_ACTION) {
628 if (ctrl == ed->addbutton) {
629 char str[sizeof(cfg->environmt)];
630 char *p;
631 dlg_editbox_get(ed->varbox, dlg, str, sizeof(str)-1);
632 if (!*str) {
633 dlg_beep(dlg);
634 return;
635 }
636 p = str + strlen(str);
637 *p++ = '\t';
638 dlg_editbox_get(ed->valbox, dlg, p, sizeof(str)-1 - (p - str));
639 if (!*p) {
640 dlg_beep(dlg);
641 return;
642 }
643 p = cfg->environmt;
644 while (*p) {
645 while (*p)
646 p++;
647 p++;
648 }
649 if ((p - cfg->environmt) + strlen(str) + 2 <
650 sizeof(cfg->environmt)) {
651 strcpy(p, str);
652 p[strlen(str) + 1] = '\0';
653 dlg_listbox_add(ed->listbox, dlg, str);
654 dlg_editbox_set(ed->varbox, dlg, "");
655 dlg_editbox_set(ed->valbox, dlg, "");
656 } else {
657 dlg_error_msg(dlg, "Environment too big");
658 }
659 } else if (ctrl == ed->rembutton) {
660 int i = dlg_listbox_index(ed->listbox, dlg);
661 if (i < 0) {
662 dlg_beep(dlg);
663 } else {
664 char *p, *q;
665
666 dlg_listbox_del(ed->listbox, dlg, i);
667 p = cfg->environmt;
668 while (i > 0) {
669 if (!*p)
670 goto disaster;
671 while (*p)
672 p++;
673 p++;
674 i--;
675 }
676 q = p;
677 if (!*p)
678 goto disaster;
679 while (*p)
680 p++;
681 p++;
682 while (*p) {
683 while (*p)
684 *q++ = *p++;
685 *q++ = *p++;
686 }
687 *q = '\0';
688 disaster:;
689 }
690 }
691 }
692 }
693
694 struct portfwd_data {
695 union control *addbutton, *rembutton, *listbox;
696 union control *sourcebox, *destbox, *direction;
697 #ifndef NO_IPV6
698 union control *addressfamily;
699 #endif
700 };
701
702 static void portfwd_handler(union control *ctrl, void *dlg,
703 void *data, int event)
704 {
705 Config *cfg = (Config *)data;
706 struct portfwd_data *pfd =
707 (struct portfwd_data *)ctrl->generic.context.p;
708
709 if (event == EVENT_REFRESH) {
710 if (ctrl == pfd->listbox) {
711 char *p = cfg->portfwd;
712 dlg_update_start(ctrl, dlg);
713 dlg_listbox_clear(ctrl, dlg);
714 while (*p) {
715 dlg_listbox_add(ctrl, dlg, p);
716 p += strlen(p) + 1;
717 }
718 dlg_update_done(ctrl, dlg);
719 } else if (ctrl == pfd->direction) {
720 /*
721 * Default is Local.
722 */
723 dlg_radiobutton_set(ctrl, dlg, 0);
724 #ifndef NO_IPV6
725 } else if (ctrl == pfd->addressfamily) {
726 dlg_radiobutton_set(ctrl, dlg, 0);
727 #endif
728 }
729 } else if (event == EVENT_ACTION) {
730 if (ctrl == pfd->addbutton) {
731 char str[sizeof(cfg->portfwd)];
732 char *p;
733 int i, type;
734 int whichbutton;
735
736 i = 0;
737 #ifndef NO_IPV6
738 whichbutton = dlg_radiobutton_get(pfd->addressfamily, dlg);
739 if (whichbutton == 1)
740 str[i++] = '4';
741 else if (whichbutton == 2)
742 str[i++] = '6';
743 #endif
744
745 whichbutton = dlg_radiobutton_get(pfd->direction, dlg);
746 if (whichbutton == 0)
747 type = 'L';
748 else if (whichbutton == 1)
749 type = 'R';
750 else
751 type = 'D';
752 str[i++] = type;
753
754 dlg_editbox_get(pfd->sourcebox, dlg, str+i, sizeof(str) - i);
755 if (!str[i]) {
756 dlg_error_msg(dlg, "You need to specify a source port number");
757 return;
758 }
759 p = str + strlen(str);
760 if (type != 'D') {
761 *p++ = '\t';
762 dlg_editbox_get(pfd->destbox, dlg, p,
763 sizeof(str) - (p - str));
764 if (!*p || !strchr(p, ':')) {
765 dlg_error_msg(dlg,
766 "You need to specify a destination address\n"
767 "in the form \"host.name:port\"");
768 return;
769 }
770 } else
771 *p = '\0';
772 p = cfg->portfwd;
773 while (*p) {
774 while (*p)
775 p++;
776 p++;
777 }
778 if ((p - cfg->portfwd) + strlen(str) + 2 <=
779 sizeof(cfg->portfwd)) {
780 strcpy(p, str);
781 p[strlen(str) + 1] = '\0';
782 dlg_listbox_add(pfd->listbox, dlg, str);
783 dlg_editbox_set(pfd->sourcebox, dlg, "");
784 dlg_editbox_set(pfd->destbox, dlg, "");
785 } else {
786 dlg_error_msg(dlg, "Too many forwardings");
787 }
788 } else if (ctrl == pfd->rembutton) {
789 int i = dlg_listbox_index(pfd->listbox, dlg);
790 if (i < 0)
791 dlg_beep(dlg);
792 else {
793 char *p, *q;
794
795 dlg_listbox_del(pfd->listbox, dlg, i);
796 p = cfg->portfwd;
797 while (i > 0) {
798 if (!*p)
799 goto disaster2;
800 while (*p)
801 p++;
802 p++;
803 i--;
804 }
805 q = p;
806 if (!*p)
807 goto disaster2;
808 while (*p)
809 p++;
810 p++;
811 while (*p) {
812 while (*p)
813 *q++ = *p++;
814 *q++ = *p++;
815 }
816 *q = '\0';
817 disaster2:;
818 }
819 }
820 }
821 }
822
823 void setup_config_box(struct controlbox *b, int midsession,
824 int protocol, int protcfginfo)
825 {
826 struct controlset *s;
827 struct sessionsaver_data *ssd;
828 struct charclass_data *ccd;
829 struct colour_data *cd;
830 struct environ_data *ed;
831 struct portfwd_data *pfd;
832 union control *c;
833 char *str;
834
835 ssd = (struct sessionsaver_data *)
836 ctrl_alloc(b, sizeof(struct sessionsaver_data));
837 memset(ssd, 0, sizeof(*ssd));
838 ssd->midsession = midsession;
839
840 /*
841 * The standard panel that appears at the bottom of all panels:
842 * Open, Cancel, Apply etc.
843 */
844 s = ctrl_getset(b, "", "", "");
845 ctrl_columns(s, 5, 20, 20, 20, 20, 20);
846 ssd->okbutton = ctrl_pushbutton(s,
847 (midsession ? "Apply" : "Open"),
848 (char)(midsession ? 'a' : 'o'),
849 HELPCTX(no_help),
850 sessionsaver_handler, P(ssd));
851 ssd->okbutton->button.isdefault = TRUE;
852 ssd->okbutton->generic.column = 3;
853 ssd->cancelbutton = ctrl_pushbutton(s, "Cancel", 'c', HELPCTX(no_help),
854 sessionsaver_handler, P(ssd));
855 ssd->cancelbutton->button.iscancel = TRUE;
856 ssd->cancelbutton->generic.column = 4;
857 /* We carefully don't close the 5-column part, so that platform-
858 * specific add-ons can put extra buttons alongside Open and Cancel. */
859
860 /*
861 * The Session panel.
862 */
863 str = dupprintf("Basic options for your %s session", appname);
864 ctrl_settitle(b, "Session", str);
865 sfree(str);
866
867 if (!midsession) {
868 s = ctrl_getset(b, "Session", "hostport",
869 "Specify your connection by host name or IP address");
870 ctrl_columns(s, 2, 75, 25);
871 c = ctrl_editbox(s, "Host Name (or IP address)", 'n', 100,
872 HELPCTX(session_hostname),
873 dlg_stdeditbox_handler, I(offsetof(Config,host)),
874 I(sizeof(((Config *)0)->host)));
875 c->generic.column = 0;
876 c = ctrl_editbox(s, "Port", 'p', 100, HELPCTX(session_hostname),
877 dlg_stdeditbox_handler,
878 I(offsetof(Config,port)), I(-1));
879 c->generic.column = 1;
880 ctrl_columns(s, 1, 100);
881 if (backends[3].name == NULL) {
882 ctrl_radiobuttons(s, "Protocol:", NO_SHORTCUT, 3,
883 HELPCTX(session_hostname),
884 protocolbuttons_handler, P(c),
885 "Raw", 'r', I(PROT_RAW),
886 "Telnet", 't', I(PROT_TELNET),
887 "Rlogin", 'i', I(PROT_RLOGIN),
888 NULL);
889 } else {
890 ctrl_radiobuttons(s, "Protocol:", NO_SHORTCUT, 4,
891 HELPCTX(session_hostname),
892 protocolbuttons_handler, P(c),
893 "Raw", 'r', I(PROT_RAW),
894 "Telnet", 't', I(PROT_TELNET),
895 "Rlogin", 'i', I(PROT_RLOGIN),
896 "SSH", 's', I(PROT_SSH),
897 NULL);
898 }
899 }
900
901 /*
902 * The Load/Save panel is available even in mid-session.
903 */
904 s = ctrl_getset(b, "Session", "savedsessions",
905 midsession ? "Save the current session settings" :
906 "Load, save or delete a stored session");
907 ctrl_columns(s, 2, 75, 25);
908 get_sesslist(&ssd->sesslist, TRUE);
909 ssd->editbox = ctrl_editbox(s, "Saved Sessions", 'e', 100,
910 HELPCTX(session_saved),
911 sessionsaver_handler, P(ssd), P(NULL));
912 ssd->editbox->generic.column = 0;
913 /* Reset columns so that the buttons are alongside the list, rather
914 * than alongside that edit box. */
915 ctrl_columns(s, 1, 100);
916 ctrl_columns(s, 2, 75, 25);
917 ssd->listbox = ctrl_listbox(s, NULL, NO_SHORTCUT,
918 HELPCTX(session_saved),
919 sessionsaver_handler, P(ssd));
920 ssd->listbox->generic.column = 0;
921 ssd->listbox->listbox.height = 7;
922 if (!midsession) {
923 ssd->loadbutton = ctrl_pushbutton(s, "Load", 'l',
924 HELPCTX(session_saved),
925 sessionsaver_handler, P(ssd));
926 ssd->loadbutton->generic.column = 1;
927 } else {
928 /* We can't offer the Load button mid-session, as it would allow the
929 * user to load and subsequently save settings they can't see. (And
930 * also change otherwise immutable settings underfoot; that probably
931 * shouldn't be a problem, but.) */
932 ssd->loadbutton = NULL;
933 }
934 /* "Save" button is permitted mid-session. */
935 ssd->savebutton = ctrl_pushbutton(s, "Save", 'v',
936 HELPCTX(session_saved),
937 sessionsaver_handler, P(ssd));
938 ssd->savebutton->generic.column = 1;
939 if (!midsession) {
940 ssd->delbutton = ctrl_pushbutton(s, "Delete", 'd',
941 HELPCTX(session_saved),
942 sessionsaver_handler, P(ssd));
943 ssd->delbutton->generic.column = 1;
944 } else {
945 /* Disable the Delete button mid-session too, for UI consistency. */
946 ssd->delbutton = NULL;
947 }
948 ctrl_columns(s, 1, 100);
949
950 s = ctrl_getset(b, "Session", "otheropts", NULL);
951 c = ctrl_radiobuttons(s, "Close window on exit:", 'w', 4,
952 HELPCTX(session_coe),
953 dlg_stdradiobutton_handler,
954 I(offsetof(Config, close_on_exit)),
955 "Always", I(FORCE_ON),
956 "Never", I(FORCE_OFF),
957 "Only on clean exit", I(AUTO), NULL);
958
959 /*
960 * The Session/Logging panel.
961 */
962 ctrl_settitle(b, "Session/Logging", "Options controlling session logging");
963
964 s = ctrl_getset(b, "Session/Logging", "main", NULL);
965 /*
966 * The logging buttons change depending on whether SSH packet
967 * logging can sensibly be available.
968 */
969 {
970 char *sshlogname;
971 if ((midsession && protocol == PROT_SSH) ||
972 (!midsession && backends[3].name != NULL))
973 sshlogname = "Log SSH packet data";
974 else
975 sshlogname = NULL; /* this will disable the button */
976 ctrl_radiobuttons(s, "Session logging:", NO_SHORTCUT, 1,
977 HELPCTX(logging_main),
978 loggingbuttons_handler,
979 I(offsetof(Config, logtype)),
980 "Logging turned off completely", 't', I(LGTYP_NONE),
981 "Log printable output only", 'p', I(LGTYP_ASCII),
982 "Log all session output", 'l', I(LGTYP_DEBUG),
983 sshlogname, 's', I(LGTYP_PACKETS),
984 NULL);
985 }
986 ctrl_filesel(s, "Log file name:", 'f',
987 NULL, TRUE, "Select session log file name",
988 HELPCTX(logging_filename),
989 dlg_stdfilesel_handler, I(offsetof(Config, logfilename)));
990 ctrl_text(s, "(Log file name can contain &Y, &M, &D for date,"
991 " &T for time, and &H for host name)",
992 HELPCTX(logging_filename));
993 ctrl_radiobuttons(s, "What to do if the log file already exists:", 'e', 1,
994 HELPCTX(logging_exists),
995 dlg_stdradiobutton_handler, I(offsetof(Config,logxfovr)),
996 "Always overwrite it", I(LGXF_OVR),
997 "Always append to the end of it", I(LGXF_APN),
998 "Ask the user every time", I(LGXF_ASK), NULL);
999 ctrl_checkbox(s, "Flush log file frequently", 'u',
1000 HELPCTX(logging_flush),
1001 dlg_stdcheckbox_handler, I(offsetof(Config,logflush)));
1002
1003 if ((midsession && protocol == PROT_SSH) ||
1004 (!midsession && backends[3].name != NULL)) {
1005 s = ctrl_getset(b, "Session/Logging", "ssh",
1006 "Options specific to SSH packet logging");
1007 ctrl_checkbox(s, "Omit known password fields", 'k',
1008 HELPCTX(logging_ssh_omit_password),
1009 dlg_stdcheckbox_handler, I(offsetof(Config,logomitpass)));
1010 ctrl_checkbox(s, "Omit session data", 'd',
1011 HELPCTX(logging_ssh_omit_data),
1012 dlg_stdcheckbox_handler, I(offsetof(Config,logomitdata)));
1013 }
1014
1015 /*
1016 * The Terminal panel.
1017 */
1018 ctrl_settitle(b, "Terminal", "Options controlling the terminal emulation");
1019
1020 s = ctrl_getset(b, "Terminal", "general", "Set various terminal options");
1021 ctrl_checkbox(s, "Auto wrap mode initially on", 'w',
1022 HELPCTX(terminal_autowrap),
1023 dlg_stdcheckbox_handler, I(offsetof(Config,wrap_mode)));
1024 ctrl_checkbox(s, "DEC Origin Mode initially on", 'd',
1025 HELPCTX(terminal_decom),
1026 dlg_stdcheckbox_handler, I(offsetof(Config,dec_om)));
1027 ctrl_checkbox(s, "Implicit CR in every LF", 'r',
1028 HELPCTX(terminal_lfhascr),
1029 dlg_stdcheckbox_handler, I(offsetof(Config,lfhascr)));
1030 ctrl_checkbox(s, "Use background colour to erase screen", 'e',
1031 HELPCTX(terminal_bce),
1032 dlg_stdcheckbox_handler, I(offsetof(Config,bce)));
1033 ctrl_checkbox(s, "Enable blinking text", 'n',
1034 HELPCTX(terminal_blink),
1035 dlg_stdcheckbox_handler, I(offsetof(Config,blinktext)));
1036 ctrl_editbox(s, "Answerback to ^E:", 's', 100,
1037 HELPCTX(terminal_answerback),
1038 dlg_stdeditbox_handler, I(offsetof(Config,answerback)),
1039 I(sizeof(((Config *)0)->answerback)));
1040
1041 s = ctrl_getset(b, "Terminal", "ldisc", "Line discipline options");
1042 ctrl_radiobuttons(s, "Local echo:", 'l', 3,
1043 HELPCTX(terminal_localecho),
1044 dlg_stdradiobutton_handler,I(offsetof(Config,localecho)),
1045 "Auto", I(AUTO),
1046 "Force on", I(FORCE_ON),
1047 "Force off", I(FORCE_OFF), NULL);
1048 ctrl_radiobuttons(s, "Local line editing:", 't', 3,
1049 HELPCTX(terminal_localedit),
1050 dlg_stdradiobutton_handler,I(offsetof(Config,localedit)),
1051 "Auto", I(AUTO),
1052 "Force on", I(FORCE_ON),
1053 "Force off", I(FORCE_OFF), NULL);
1054
1055 s = ctrl_getset(b, "Terminal", "printing", "Remote-controlled printing");
1056 ctrl_combobox(s, "Printer to send ANSI printer output to:", 'p', 100,
1057 HELPCTX(terminal_printing),
1058 printerbox_handler, P(NULL), P(NULL));
1059
1060 /*
1061 * The Terminal/Keyboard panel.
1062 */
1063 ctrl_settitle(b, "Terminal/Keyboard",
1064 "Options controlling the effects of keys");
1065
1066 s = ctrl_getset(b, "Terminal/Keyboard", "mappings",
1067 "Change the sequences sent by:");
1068 ctrl_radiobuttons(s, "The Backspace key", 'b', 2,
1069 HELPCTX(keyboard_backspace),
1070 dlg_stdradiobutton_handler,
1071 I(offsetof(Config, bksp_is_delete)),
1072 "Control-H", I(0), "Control-? (127)", I(1), NULL);
1073 ctrl_radiobuttons(s, "The Home and End keys", 'e', 2,
1074 HELPCTX(keyboard_homeend),
1075 dlg_stdradiobutton_handler,
1076 I(offsetof(Config, rxvt_homeend)),
1077 "Standard", I(0), "rxvt", I(1), NULL);
1078 ctrl_radiobuttons(s, "The Function keys and keypad", 'f', 3,
1079 HELPCTX(keyboard_funkeys),
1080 dlg_stdradiobutton_handler,
1081 I(offsetof(Config, funky_type)),
1082 "ESC[n~", I(0), "Linux", I(1), "Xterm R6", I(2),
1083 "VT400", I(3), "VT100+", I(4), "SCO", I(5), NULL);
1084
1085 s = ctrl_getset(b, "Terminal/Keyboard", "appkeypad",
1086 "Application keypad settings:");
1087 ctrl_radiobuttons(s, "Initial state of cursor keys:", 'r', 3,
1088 HELPCTX(keyboard_appcursor),
1089 dlg_stdradiobutton_handler,
1090 I(offsetof(Config, app_cursor)),
1091 "Normal", I(0), "Application", I(1), NULL);
1092 ctrl_radiobuttons(s, "Initial state of numeric keypad:", 'n', 3,
1093 HELPCTX(keyboard_appkeypad),
1094 numeric_keypad_handler, P(NULL),
1095 "Normal", I(0), "Application", I(1), "NetHack", I(2),
1096 NULL);
1097
1098 /*
1099 * The Terminal/Bell panel.
1100 */
1101 ctrl_settitle(b, "Terminal/Bell",
1102 "Options controlling the terminal bell");
1103
1104 s = ctrl_getset(b, "Terminal/Bell", "style", "Set the style of bell");
1105 ctrl_radiobuttons(s, "Action to happen when a bell occurs:", 'b', 1,
1106 HELPCTX(bell_style),
1107 dlg_stdradiobutton_handler, I(offsetof(Config, beep)),
1108 "None (bell disabled)", I(BELL_DISABLED),
1109 "Make default system alert sound", I(BELL_DEFAULT),
1110 "Visual bell (flash window)", I(BELL_VISUAL), NULL);
1111
1112 s = ctrl_getset(b, "Terminal/Bell", "overload",
1113 "Control the bell overload behaviour");
1114 ctrl_checkbox(s, "Bell is temporarily disabled when over-used", 'd',
1115 HELPCTX(bell_overload),
1116 dlg_stdcheckbox_handler, I(offsetof(Config,bellovl)));
1117 ctrl_editbox(s, "Over-use means this many bells...", 'm', 20,
1118 HELPCTX(bell_overload),
1119 dlg_stdeditbox_handler, I(offsetof(Config,bellovl_n)), I(-1));
1120 ctrl_editbox(s, "... in this many seconds", 't', 20,
1121 HELPCTX(bell_overload),
1122 dlg_stdeditbox_handler, I(offsetof(Config,bellovl_t)),
1123 I(-TICKSPERSEC));
1124 ctrl_text(s, "The bell is re-enabled after a few seconds of silence.",
1125 HELPCTX(bell_overload));
1126 ctrl_editbox(s, "Seconds of silence required", 's', 20,
1127 HELPCTX(bell_overload),
1128 dlg_stdeditbox_handler, I(offsetof(Config,bellovl_s)),
1129 I(-TICKSPERSEC));
1130
1131 /*
1132 * The Terminal/Features panel.
1133 */
1134 ctrl_settitle(b, "Terminal/Features",
1135 "Enabling and disabling advanced terminal features");
1136
1137 s = ctrl_getset(b, "Terminal/Features", "main", NULL);
1138 ctrl_checkbox(s, "Disable application cursor keys mode", 'u',
1139 HELPCTX(features_application),
1140 dlg_stdcheckbox_handler, I(offsetof(Config,no_applic_c)));
1141 ctrl_checkbox(s, "Disable application keypad mode", 'k',
1142 HELPCTX(features_application),
1143 dlg_stdcheckbox_handler, I(offsetof(Config,no_applic_k)));
1144 ctrl_checkbox(s, "Disable xterm-style mouse reporting", 'x',
1145 HELPCTX(features_mouse),
1146 dlg_stdcheckbox_handler, I(offsetof(Config,no_mouse_rep)));
1147 ctrl_checkbox(s, "Disable remote-controlled terminal resizing", 's',
1148 HELPCTX(features_resize),
1149 dlg_stdcheckbox_handler,
1150 I(offsetof(Config,no_remote_resize)));
1151 ctrl_checkbox(s, "Disable switching to alternate terminal screen", 'w',
1152 HELPCTX(features_altscreen),
1153 dlg_stdcheckbox_handler, I(offsetof(Config,no_alt_screen)));
1154 ctrl_checkbox(s, "Disable remote-controlled window title changing", 't',
1155 HELPCTX(features_retitle),
1156 dlg_stdcheckbox_handler,
1157 I(offsetof(Config,no_remote_wintitle)));
1158 ctrl_checkbox(s, "Disable remote window title querying (SECURITY)",
1159 'q', HELPCTX(features_qtitle), dlg_stdcheckbox_handler,
1160 I(offsetof(Config,no_remote_qtitle)));
1161 ctrl_checkbox(s, "Disable destructive backspace on server sending ^?",'b',
1162 HELPCTX(features_dbackspace),
1163 dlg_stdcheckbox_handler, I(offsetof(Config,no_dbackspace)));
1164 ctrl_checkbox(s, "Disable remote-controlled character set configuration",
1165 'r', HELPCTX(features_charset), dlg_stdcheckbox_handler,
1166 I(offsetof(Config,no_remote_charset)));
1167 ctrl_checkbox(s, "Disable Arabic text shaping",
1168 'l', HELPCTX(features_arabicshaping), dlg_stdcheckbox_handler,
1169 I(offsetof(Config, arabicshaping)));
1170 ctrl_checkbox(s, "Disable bidirectional text display",
1171 'd', HELPCTX(features_bidi), dlg_stdcheckbox_handler,
1172 I(offsetof(Config, bidi)));
1173
1174 /*
1175 * The Window panel.
1176 */
1177 str = dupprintf("Options controlling %s's window", appname);
1178 ctrl_settitle(b, "Window", str);
1179 sfree(str);
1180
1181 s = ctrl_getset(b, "Window", "size", "Set the size of the window");
1182 ctrl_columns(s, 2, 50, 50);
1183 c = ctrl_editbox(s, "Rows", 'r', 100,
1184 HELPCTX(window_size),
1185 dlg_stdeditbox_handler, I(offsetof(Config,height)),I(-1));
1186 c->generic.column = 0;
1187 c = ctrl_editbox(s, "Columns", 'm', 100,
1188 HELPCTX(window_size),
1189 dlg_stdeditbox_handler, I(offsetof(Config,width)), I(-1));
1190 c->generic.column = 1;
1191 ctrl_columns(s, 1, 100);
1192
1193 s = ctrl_getset(b, "Window", "scrollback",
1194 "Control the scrollback in the window");
1195 ctrl_editbox(s, "Lines of scrollback", 's', 50,
1196 HELPCTX(window_scrollback),
1197 dlg_stdeditbox_handler, I(offsetof(Config,savelines)), I(-1));
1198 ctrl_checkbox(s, "Display scrollbar", 'd',
1199 HELPCTX(window_scrollback),
1200 dlg_stdcheckbox_handler, I(offsetof(Config,scrollbar)));
1201 ctrl_checkbox(s, "Reset scrollback on keypress", 'k',
1202 HELPCTX(window_scrollback),
1203 dlg_stdcheckbox_handler, I(offsetof(Config,scroll_on_key)));
1204 ctrl_checkbox(s, "Reset scrollback on display activity", 'p',
1205 HELPCTX(window_scrollback),
1206 dlg_stdcheckbox_handler, I(offsetof(Config,scroll_on_disp)));
1207 ctrl_checkbox(s, "Push erased text into scrollback", 'e',
1208 HELPCTX(window_erased),
1209 dlg_stdcheckbox_handler,
1210 I(offsetof(Config,erase_to_scrollback)));
1211
1212 /*
1213 * The Window/Appearance panel.
1214 */
1215 str = dupprintf("Configure the appearance of %s's window", appname);
1216 ctrl_settitle(b, "Window/Appearance", str);
1217 sfree(str);
1218
1219 s = ctrl_getset(b, "Window/Appearance", "cursor",
1220 "Adjust the use of the cursor");
1221 ctrl_radiobuttons(s, "Cursor appearance:", NO_SHORTCUT, 3,
1222 HELPCTX(appearance_cursor),
1223 dlg_stdradiobutton_handler,
1224 I(offsetof(Config, cursor_type)),
1225 "Block", 'l', I(0),
1226 "Underline", 'u', I(1),
1227 "Vertical line", 'v', I(2), NULL);
1228 ctrl_checkbox(s, "Cursor blinks", 'b',
1229 HELPCTX(appearance_cursor),
1230 dlg_stdcheckbox_handler, I(offsetof(Config,blink_cur)));
1231
1232 s = ctrl_getset(b, "Window/Appearance", "font",
1233 "Font settings");
1234 ctrl_fontsel(s, "Font used in the terminal window", 'n',
1235 HELPCTX(appearance_font),
1236 dlg_stdfontsel_handler, I(offsetof(Config, font)));
1237
1238 s = ctrl_getset(b, "Window/Appearance", "mouse",
1239 "Adjust the use of the mouse pointer");
1240 ctrl_checkbox(s, "Hide mouse pointer when typing in window", 'p',
1241 HELPCTX(appearance_hidemouse),
1242 dlg_stdcheckbox_handler, I(offsetof(Config,hide_mouseptr)));
1243
1244 s = ctrl_getset(b, "Window/Appearance", "border",
1245 "Adjust the window border");
1246 ctrl_editbox(s, "Gap between text and window edge:", 'e', 20,
1247 HELPCTX(appearance_border),
1248 dlg_stdeditbox_handler,
1249 I(offsetof(Config,window_border)), I(-1));
1250
1251 /*
1252 * The Window/Behaviour panel.
1253 */
1254 str = dupprintf("Configure the behaviour of %s's window", appname);
1255 ctrl_settitle(b, "Window/Behaviour", str);
1256 sfree(str);
1257
1258 s = ctrl_getset(b, "Window/Behaviour", "title",
1259 "Adjust the behaviour of the window title");
1260 ctrl_editbox(s, "Window title:", 't', 100,
1261 HELPCTX(appearance_title),
1262 dlg_stdeditbox_handler, I(offsetof(Config,wintitle)),
1263 I(sizeof(((Config *)0)->wintitle)));
1264 ctrl_checkbox(s, "Separate window and icon titles", 'i',
1265 HELPCTX(appearance_title),
1266 dlg_stdcheckbox_handler,
1267 I(CHECKBOX_INVERT | offsetof(Config,win_name_always)));
1268
1269 s = ctrl_getset(b, "Window/Behaviour", "main", NULL);
1270 ctrl_checkbox(s, "Warn before closing window", 'w',
1271 HELPCTX(behaviour_closewarn),
1272 dlg_stdcheckbox_handler, I(offsetof(Config,warn_on_close)));
1273
1274 /*
1275 * The Window/Translation panel.
1276 */
1277 ctrl_settitle(b, "Window/Translation",
1278 "Options controlling character set translation");
1279
1280 s = ctrl_getset(b, "Window/Translation", "trans",
1281 "Character set translation on received data");
1282 ctrl_combobox(s, "Received data assumed to be in which character set:",
1283 'r', 100, HELPCTX(translation_codepage),
1284 codepage_handler, P(NULL), P(NULL));
1285
1286 s = ctrl_getset(b, "Window/Translation", "tweaks", NULL);
1287 ctrl_checkbox(s, "Treat CJK ambiguous characters as wide", 'w',
1288 HELPCTX(translation_cjk_ambig_wide),
1289 dlg_stdcheckbox_handler, I(offsetof(Config,cjk_ambig_wide)));
1290
1291 str = dupprintf("Adjust how %s handles line drawing characters", appname);
1292 s = ctrl_getset(b, "Window/Translation", "linedraw", str);
1293 sfree(str);
1294 ctrl_radiobuttons(s, "Handling of line drawing characters:", NO_SHORTCUT,1,
1295 HELPCTX(translation_linedraw),
1296 dlg_stdradiobutton_handler,
1297 I(offsetof(Config, vtmode)),
1298 "Use Unicode line drawing code points",'u',I(VT_UNICODE),
1299 "Poor man's line drawing (+, - and |)",'p',I(VT_POORMAN),
1300 NULL);
1301 ctrl_checkbox(s, "Copy and paste line drawing characters as lqqqk",'d',
1302 HELPCTX(selection_linedraw),
1303 dlg_stdcheckbox_handler, I(offsetof(Config,rawcnp)));
1304
1305 /*
1306 * The Window/Selection panel.
1307 */
1308 ctrl_settitle(b, "Window/Selection", "Options controlling copy and paste");
1309
1310 s = ctrl_getset(b, "Window/Selection", "mouse",
1311 "Control use of mouse");
1312 ctrl_checkbox(s, "Shift overrides application's use of mouse", 'p',
1313 HELPCTX(selection_shiftdrag),
1314 dlg_stdcheckbox_handler, I(offsetof(Config,mouse_override)));
1315 ctrl_radiobuttons(s,
1316 "Default selection mode (Alt+drag does the other one):",
1317 NO_SHORTCUT, 2,
1318 HELPCTX(selection_rect),
1319 dlg_stdradiobutton_handler,
1320 I(offsetof(Config, rect_select)),
1321 "Normal", 'n', I(0),
1322 "Rectangular block", 'r', I(1), NULL);
1323
1324 s = ctrl_getset(b, "Window/Selection", "charclass",
1325 "Control the select-one-word-at-a-time mode");
1326 ccd = (struct charclass_data *)
1327 ctrl_alloc(b, sizeof(struct charclass_data));
1328 ccd->listbox = ctrl_listbox(s, "Character classes:", 'e',
1329 HELPCTX(selection_charclasses),
1330 charclass_handler, P(ccd));
1331 ccd->listbox->listbox.multisel = 1;
1332 ccd->listbox->listbox.ncols = 4;
1333 ccd->listbox->listbox.percentages = snewn(4, int);
1334 ccd->listbox->listbox.percentages[0] = 15;
1335 ccd->listbox->listbox.percentages[1] = 25;
1336 ccd->listbox->listbox.percentages[2] = 20;
1337 ccd->listbox->listbox.percentages[3] = 40;
1338 ctrl_columns(s, 2, 67, 33);
1339 ccd->editbox = ctrl_editbox(s, "Set to class", 't', 50,
1340 HELPCTX(selection_charclasses),
1341 charclass_handler, P(ccd), P(NULL));
1342 ccd->editbox->generic.column = 0;
1343 ccd->button = ctrl_pushbutton(s, "Set", 's',
1344 HELPCTX(selection_charclasses),
1345 charclass_handler, P(ccd));
1346 ccd->button->generic.column = 1;
1347 ctrl_columns(s, 1, 100);
1348
1349 /*
1350 * The Window/Colours panel.
1351 */
1352 ctrl_settitle(b, "Window/Colours", "Options controlling use of colours");
1353
1354 s = ctrl_getset(b, "Window/Colours", "general",
1355 "General options for colour usage");
1356 ctrl_checkbox(s, "Allow terminal to specify ANSI colours", 'i',
1357 HELPCTX(colours_ansi),
1358 dlg_stdcheckbox_handler, I(offsetof(Config,ansi_colour)));
1359 ctrl_checkbox(s, "Allow terminal to use xterm 256-colour mode", '2',
1360 HELPCTX(colours_xterm256), dlg_stdcheckbox_handler,
1361 I(offsetof(Config,xterm_256_colour)));
1362 ctrl_checkbox(s, "Bolded text is a different colour", 'b',
1363 HELPCTX(colours_bold),
1364 dlg_stdcheckbox_handler, I(offsetof(Config,bold_colour)));
1365
1366 str = dupprintf("Adjust the precise colours %s displays", appname);
1367 s = ctrl_getset(b, "Window/Colours", "adjust", str);
1368 sfree(str);
1369 ctrl_text(s, "Select a colour from the list, and then click the"
1370 " Modify button to change its appearance.",
1371 HELPCTX(colours_config));
1372 ctrl_columns(s, 2, 67, 33);
1373 cd = (struct colour_data *)ctrl_alloc(b, sizeof(struct colour_data));
1374 cd->listbox = ctrl_listbox(s, "Select a colour to adjust:", 'u',
1375 HELPCTX(colours_config), colour_handler, P(cd));
1376 cd->listbox->generic.column = 0;
1377 cd->listbox->listbox.height = 7;
1378 c = ctrl_text(s, "RGB value:", HELPCTX(colours_config));
1379 c->generic.column = 1;
1380 cd->redit = ctrl_editbox(s, "Red", 'r', 50, HELPCTX(colours_config),
1381 colour_handler, P(cd), P(NULL));
1382 cd->redit->generic.column = 1;
1383 cd->gedit = ctrl_editbox(s, "Green", 'n', 50, HELPCTX(colours_config),
1384 colour_handler, P(cd), P(NULL));
1385 cd->gedit->generic.column = 1;
1386 cd->bedit = ctrl_editbox(s, "Blue", 'e', 50, HELPCTX(colours_config),
1387 colour_handler, P(cd), P(NULL));
1388 cd->bedit->generic.column = 1;
1389 cd->button = ctrl_pushbutton(s, "Modify", 'm', HELPCTX(colours_config),
1390 colour_handler, P(cd));
1391 cd->button->generic.column = 1;
1392 ctrl_columns(s, 1, 100);
1393
1394 /*
1395 * The Connection panel. This doesn't show up if we're in a
1396 * non-network utility such as pterm. We tell this by being
1397 * passed a protocol < 0.
1398 */
1399 if (protocol >= 0) {
1400 ctrl_settitle(b, "Connection", "Options controlling the connection");
1401
1402 s = ctrl_getset(b, "Connection", "keepalive",
1403 "Sending of null packets to keep session active");
1404 ctrl_editbox(s, "Seconds between keepalives (0 to turn off)", 'k', 20,
1405 HELPCTX(connection_keepalive),
1406 dlg_stdeditbox_handler, I(offsetof(Config,ping_interval)),
1407 I(-1));
1408
1409 if (!midsession) {
1410 s = ctrl_getset(b, "Connection", "tcp",
1411 "Low-level TCP connection options");
1412 ctrl_checkbox(s, "Disable Nagle's algorithm (TCP_NODELAY option)",
1413 'n', HELPCTX(connection_nodelay),
1414 dlg_stdcheckbox_handler,
1415 I(offsetof(Config,tcp_nodelay)));
1416 ctrl_checkbox(s, "Enable TCP keepalives (SO_KEEPALIVE option)",
1417 'p', HELPCTX(connection_tcpkeepalive),
1418 dlg_stdcheckbox_handler,
1419 I(offsetof(Config,tcp_keepalives)));
1420 #ifndef NO_IPV6
1421 s = ctrl_getset(b, "Connection", "ipversion",
1422 "Internet protocol version");
1423 ctrl_radiobuttons(s, NULL, NO_SHORTCUT, 3,
1424 HELPCTX(connection_ipversion),
1425 dlg_stdradiobutton_handler,
1426 I(offsetof(Config, addressfamily)),
1427 "Auto", 'u', I(ADDRTYPE_UNSPEC),
1428 "IPv4", '4', I(ADDRTYPE_IPV4),
1429 "IPv6", '6', I(ADDRTYPE_IPV6),
1430 NULL);
1431 #endif
1432 }
1433
1434 /*
1435 * A sub-panel Connection/Data, containing options that
1436 * decide on data to send to the server.
1437 */
1438 if (!midsession) {
1439 ctrl_settitle(b, "Connection/Data", "Data to send to the server");
1440
1441 s = ctrl_getset(b, "Connection/Data", "login",
1442 "Login details");
1443 ctrl_editbox(s, "Auto-login username", 'u', 50,
1444 HELPCTX(connection_username),
1445 dlg_stdeditbox_handler, I(offsetof(Config,username)),
1446 I(sizeof(((Config *)0)->username)));
1447
1448 s = ctrl_getset(b, "Connection/Data", "term",
1449 "Terminal details");
1450 ctrl_editbox(s, "Terminal-type string", 't', 50,
1451 HELPCTX(connection_termtype),
1452 dlg_stdeditbox_handler, I(offsetof(Config,termtype)),
1453 I(sizeof(((Config *)0)->termtype)));
1454 ctrl_editbox(s, "Terminal speeds", 's', 50,
1455 HELPCTX(connection_termspeed),
1456 dlg_stdeditbox_handler, I(offsetof(Config,termspeed)),
1457 I(sizeof(((Config *)0)->termspeed)));
1458
1459 s = ctrl_getset(b, "Connection/Data", "env",
1460 "Environment variables");
1461 ctrl_columns(s, 2, 80, 20);
1462 ed = (struct environ_data *)
1463 ctrl_alloc(b, sizeof(struct environ_data));
1464 ed->varbox = ctrl_editbox(s, "Variable", 'v', 60,
1465 HELPCTX(telnet_environ),
1466 environ_handler, P(ed), P(NULL));
1467 ed->varbox->generic.column = 0;
1468 ed->valbox = ctrl_editbox(s, "Value", 'l', 60,
1469 HELPCTX(telnet_environ),
1470 environ_handler, P(ed), P(NULL));
1471 ed->valbox->generic.column = 0;
1472 ed->addbutton = ctrl_pushbutton(s, "Add", 'd',
1473 HELPCTX(telnet_environ),
1474 environ_handler, P(ed));
1475 ed->addbutton->generic.column = 1;
1476 ed->rembutton = ctrl_pushbutton(s, "Remove", 'r',
1477 HELPCTX(telnet_environ),
1478 environ_handler, P(ed));
1479 ed->rembutton->generic.column = 1;
1480 ctrl_columns(s, 1, 100);
1481 ed->listbox = ctrl_listbox(s, NULL, NO_SHORTCUT,
1482 HELPCTX(telnet_environ),
1483 environ_handler, P(ed));
1484 ed->listbox->listbox.height = 3;
1485 ed->listbox->listbox.ncols = 2;
1486 ed->listbox->listbox.percentages = snewn(2, int);
1487 ed->listbox->listbox.percentages[0] = 30;
1488 ed->listbox->listbox.percentages[1] = 70;
1489 }
1490
1491 }
1492
1493 if (!midsession) {
1494 /*
1495 * The Connection/Proxy panel.
1496 */
1497 ctrl_settitle(b, "Connection/Proxy",
1498 "Options controlling proxy usage");
1499
1500 s = ctrl_getset(b, "Connection/Proxy", "basics", NULL);
1501 ctrl_radiobuttons(s, "Proxy type:", 't', 3,
1502 HELPCTX(proxy_type),
1503 dlg_stdradiobutton_handler,
1504 I(offsetof(Config, proxy_type)),
1505 "None", I(PROXY_NONE),
1506 "SOCKS 4", I(PROXY_SOCKS4),
1507 "SOCKS 5", I(PROXY_SOCKS5),
1508 "HTTP", I(PROXY_HTTP),
1509 "Telnet", I(PROXY_TELNET),
1510 NULL);
1511 ctrl_columns(s, 2, 80, 20);
1512 c = ctrl_editbox(s, "Proxy hostname", 'y', 100,
1513 HELPCTX(proxy_main),
1514 dlg_stdeditbox_handler,
1515 I(offsetof(Config,proxy_host)),
1516 I(sizeof(((Config *)0)->proxy_host)));
1517 c->generic.column = 0;
1518 c = ctrl_editbox(s, "Port", 'p', 100,
1519 HELPCTX(proxy_main),
1520 dlg_stdeditbox_handler,
1521 I(offsetof(Config,proxy_port)),
1522 I(-1));
1523 c->generic.column = 1;
1524 ctrl_columns(s, 1, 100);
1525 ctrl_editbox(s, "Exclude Hosts/IPs", 'e', 100,
1526 HELPCTX(proxy_exclude),
1527 dlg_stdeditbox_handler,
1528 I(offsetof(Config,proxy_exclude_list)),
1529 I(sizeof(((Config *)0)->proxy_exclude_list)));
1530 ctrl_checkbox(s, "Consider proxying local host connections", 'x',
1531 HELPCTX(proxy_exclude),
1532 dlg_stdcheckbox_handler,
1533 I(offsetof(Config,even_proxy_localhost)));
1534 ctrl_radiobuttons(s, "Do DNS name lookup at proxy end:", 'd', 3,
1535 HELPCTX(proxy_dns),
1536 dlg_stdradiobutton_handler,
1537 I(offsetof(Config, proxy_dns)),
1538 "No", I(FORCE_OFF),
1539 "Auto", I(AUTO),
1540 "Yes", I(FORCE_ON), NULL);
1541 ctrl_editbox(s, "Username", 'u', 60,
1542 HELPCTX(proxy_auth),
1543 dlg_stdeditbox_handler,
1544 I(offsetof(Config,proxy_username)),
1545 I(sizeof(((Config *)0)->proxy_username)));
1546 c = ctrl_editbox(s, "Password", 'w', 60,
1547 HELPCTX(proxy_auth),
1548 dlg_stdeditbox_handler,
1549 I(offsetof(Config,proxy_password)),
1550 I(sizeof(((Config *)0)->proxy_password)));
1551 c->editbox.password = 1;
1552 ctrl_editbox(s, "Telnet command", 'm', 100,
1553 HELPCTX(proxy_command),
1554 dlg_stdeditbox_handler,
1555 I(offsetof(Config,proxy_telnet_command)),
1556 I(sizeof(((Config *)0)->proxy_telnet_command)));
1557 }
1558
1559 /*
1560 * The Telnet panel exists in the base config box, and in a
1561 * mid-session reconfig box _if_ we're using Telnet.
1562 */
1563 if (!midsession || protocol == PROT_TELNET) {
1564 /*
1565 * The Connection/Telnet panel.
1566 */
1567 ctrl_settitle(b, "Connection/Telnet",
1568 "Options controlling Telnet connections");
1569
1570 s = ctrl_getset(b, "Connection/Telnet", "protocol",
1571 "Telnet protocol adjustments");
1572
1573 if (!midsession) {
1574 ctrl_radiobuttons(s, "Handling of OLD_ENVIRON ambiguity:",
1575 NO_SHORTCUT, 2,
1576 HELPCTX(telnet_oldenviron),
1577 dlg_stdradiobutton_handler,
1578 I(offsetof(Config, rfc_environ)),
1579 "BSD (commonplace)", 'b', I(0),
1580 "RFC 1408 (unusual)", 'f', I(1), NULL);
1581 ctrl_radiobuttons(s, "Telnet negotiation mode:", 't', 2,
1582 HELPCTX(telnet_passive),
1583 dlg_stdradiobutton_handler,
1584 I(offsetof(Config, passive_telnet)),
1585 "Passive", I(1), "Active", I(0), NULL);
1586 }
1587 ctrl_checkbox(s, "Keyboard sends Telnet special commands", 'k',
1588 HELPCTX(telnet_specialkeys),
1589 dlg_stdcheckbox_handler,
1590 I(offsetof(Config,telnet_keyboard)));
1591 ctrl_checkbox(s, "Return key sends Telnet New Line instead of ^M",
1592 'm', HELPCTX(telnet_newline),
1593 dlg_stdcheckbox_handler,
1594 I(offsetof(Config,telnet_newline)));
1595 }
1596
1597 if (!midsession) {
1598
1599 /*
1600 * The Connection/Rlogin panel.
1601 */
1602 ctrl_settitle(b, "Connection/Rlogin",
1603 "Options controlling Rlogin connections");
1604
1605 s = ctrl_getset(b, "Connection/Rlogin", "data",
1606 "Data to send to the server");
1607 ctrl_editbox(s, "Local username:", 'l', 50,
1608 HELPCTX(rlogin_localuser),
1609 dlg_stdeditbox_handler, I(offsetof(Config,localusername)),
1610 I(sizeof(((Config *)0)->localusername)));
1611
1612 }
1613
1614 /*
1615 * All the SSH stuff is omitted in PuTTYtel, or in a reconfig
1616 * when we're not doing SSH.
1617 */
1618
1619 if (backends[3].name != NULL && (!midsession || protocol == PROT_SSH)) {
1620
1621 /*
1622 * The Connection/SSH panel.
1623 */
1624 ctrl_settitle(b, "Connection/SSH",
1625 "Options controlling SSH connections");
1626
1627 if (midsession && protcfginfo == 1) {
1628 s = ctrl_getset(b, "Connection/SSH", "disclaimer", NULL);
1629 ctrl_text(s, "Nothing on this panel may be reconfigured in mid-"
1630 "session; it is only here so that sub-panels of it can "
1631 "exist without looking strange.", HELPCTX(no_help));
1632 }
1633
1634 if (!midsession) {
1635
1636 s = ctrl_getset(b, "Connection/SSH", "data",
1637 "Data to send to the server");
1638 ctrl_editbox(s, "Remote command:", 'r', 100,
1639 HELPCTX(ssh_command),
1640 dlg_stdeditbox_handler, I(offsetof(Config,remote_cmd)),
1641 I(sizeof(((Config *)0)->remote_cmd)));
1642
1643 s = ctrl_getset(b, "Connection/SSH", "protocol", "Protocol options");
1644 ctrl_checkbox(s, "Don't allocate a pseudo-terminal", 'p',
1645 HELPCTX(ssh_nopty),
1646 dlg_stdcheckbox_handler,
1647 I(offsetof(Config,nopty)));
1648 ctrl_checkbox(s, "Don't start a shell or command at all", 'n',
1649 HELPCTX(ssh_noshell),
1650 dlg_stdcheckbox_handler,
1651 I(offsetof(Config,ssh_no_shell)));
1652 }
1653
1654 if (!midsession || protcfginfo != 1) {
1655 s = ctrl_getset(b, "Connection/SSH", "protocol", "Protocol options");
1656
1657 ctrl_checkbox(s, "Enable compression", 'e',
1658 HELPCTX(ssh_compress),
1659 dlg_stdcheckbox_handler,
1660 I(offsetof(Config,compression)));
1661 }
1662
1663 if (!midsession) {
1664 s = ctrl_getset(b, "Connection/SSH", "protocol", "Protocol options");
1665
1666 ctrl_radiobuttons(s, "Preferred SSH protocol version:", NO_SHORTCUT, 4,
1667 HELPCTX(ssh_protocol),
1668 dlg_stdradiobutton_handler,
1669 I(offsetof(Config, sshprot)),
1670 "1 only", 'l', I(0),
1671 "1", '1', I(1),
1672 "2", '2', I(2),
1673 "2 only", 'y', I(3), NULL);
1674 }
1675
1676 if (!midsession || protcfginfo != 1) {
1677 s = ctrl_getset(b, "Connection/SSH", "encryption", "Encryption options");
1678 c = ctrl_draglist(s, "Encryption cipher selection policy:", 's',
1679 HELPCTX(ssh_ciphers),
1680 cipherlist_handler, P(NULL));
1681 c->listbox.height = 6;
1682
1683 ctrl_checkbox(s, "Enable legacy use of single-DES in SSH-2", 'i',
1684 HELPCTX(ssh_ciphers),
1685 dlg_stdcheckbox_handler,
1686 I(offsetof(Config,ssh2_des_cbc)));
1687 }
1688
1689 /*
1690 * The Connection/SSH/Kex panel. (Owing to repeat key
1691 * exchange, this is all meaningful in mid-session _if_
1692 * we're using SSH-2 or haven't decided yet.)
1693 */
1694 if (protcfginfo != 1) {
1695 ctrl_settitle(b, "Connection/SSH/Kex",
1696 "Options controlling SSH key exchange");
1697
1698 s = ctrl_getset(b, "Connection/SSH/Kex", "main",
1699 "Key exchange algorithm options");
1700 c = ctrl_draglist(s, "Algorithm selection policy:", 's',
1701 HELPCTX(ssh_kexlist),
1702 kexlist_handler, P(NULL));
1703 c->listbox.height = 5;
1704
1705 s = ctrl_getset(b, "Connection/SSH/Kex", "repeat",
1706 "Options controlling key re-exchange");
1707
1708 ctrl_editbox(s, "Max minutes before rekey (0 for no limit)", 't', 20,
1709 HELPCTX(ssh_kex_repeat),
1710 dlg_stdeditbox_handler,
1711 I(offsetof(Config,ssh_rekey_time)),
1712 I(-1));
1713 ctrl_editbox(s, "Max data before rekey (0 for no limit)", 'x', 20,
1714 HELPCTX(ssh_kex_repeat),
1715 dlg_stdeditbox_handler,
1716 I(offsetof(Config,ssh_rekey_data)),
1717 I(16));
1718 ctrl_text(s, "(Use 1M for 1 megabyte, 1G for 1 gigabyte etc)",
1719 HELPCTX(ssh_kex_repeat));
1720 }
1721
1722 if (!midsession) {
1723
1724 /*
1725 * The Connection/SSH/Auth panel.
1726 */
1727 ctrl_settitle(b, "Connection/SSH/Auth",
1728 "Options controlling SSH authentication");
1729
1730 s = ctrl_getset(b, "Connection/SSH/Auth", "methods",
1731 "Authentication methods");
1732 ctrl_checkbox(s, "Attempt TIS or CryptoCard auth (SSH-1)", 'm',
1733 HELPCTX(ssh_auth_tis),
1734 dlg_stdcheckbox_handler,
1735 I(offsetof(Config,try_tis_auth)));
1736 ctrl_checkbox(s, "Attempt \"keyboard-interactive\" auth (SSH-2)",
1737 'i', HELPCTX(ssh_auth_ki),
1738 dlg_stdcheckbox_handler,
1739 I(offsetof(Config,try_ki_auth)));
1740
1741 s = ctrl_getset(b, "Connection/SSH/Auth", "params",
1742 "Authentication parameters");
1743 ctrl_checkbox(s, "Allow agent forwarding", 'f',
1744 HELPCTX(ssh_auth_agentfwd),
1745 dlg_stdcheckbox_handler, I(offsetof(Config,agentfwd)));
1746 ctrl_checkbox(s, "Allow attempted changes of username in SSH-2", 'u',
1747 HELPCTX(ssh_auth_changeuser),
1748 dlg_stdcheckbox_handler,
1749 I(offsetof(Config,change_username)));
1750 ctrl_filesel(s, "Private key file for authentication:", 'k',
1751 FILTER_KEY_FILES, FALSE, "Select private key file",
1752 HELPCTX(ssh_auth_privkey),
1753 dlg_stdfilesel_handler, I(offsetof(Config, keyfile)));
1754 }
1755
1756 if (!midsession) {
1757 /*
1758 * The Connection/SSH/X11 panel.
1759 */
1760 ctrl_settitle(b, "Connection/SSH/X11",
1761 "Options controlling SSH X11 forwarding");
1762
1763 s = ctrl_getset(b, "Connection/SSH/X11", "x11", "X11 forwarding");
1764 ctrl_checkbox(s, "Enable X11 forwarding", 'e',
1765 HELPCTX(ssh_tunnels_x11),
1766 dlg_stdcheckbox_handler,I(offsetof(Config,x11_forward)));
1767 ctrl_editbox(s, "X display location", 'x', 50,
1768 HELPCTX(ssh_tunnels_x11),
1769 dlg_stdeditbox_handler, I(offsetof(Config,x11_display)),
1770 I(sizeof(((Config *)0)->x11_display)));
1771 ctrl_radiobuttons(s, "Remote X11 authentication protocol", 'u', 2,
1772 HELPCTX(ssh_tunnels_x11auth),
1773 dlg_stdradiobutton_handler,
1774 I(offsetof(Config, x11_auth)),
1775 "MIT-Magic-Cookie-1", I(X11_MIT),
1776 "XDM-Authorization-1", I(X11_XDM), NULL);
1777 }
1778
1779 /*
1780 * The Tunnels panel _is_ still available in mid-session.
1781 */
1782 ctrl_settitle(b, "Connection/SSH/Tunnels",
1783 "Options controlling SSH port forwarding");
1784
1785 s = ctrl_getset(b, "Connection/SSH/Tunnels", "portfwd",
1786 "Port forwarding");
1787 ctrl_checkbox(s, "Local ports accept connections from other hosts",'t',
1788 HELPCTX(ssh_tunnels_portfwd_localhost),
1789 dlg_stdcheckbox_handler,
1790 I(offsetof(Config,lport_acceptall)));
1791 ctrl_checkbox(s, "Remote ports do the same (SSH-2 only)", 'p',
1792 HELPCTX(ssh_tunnels_portfwd_localhost),
1793 dlg_stdcheckbox_handler,
1794 I(offsetof(Config,rport_acceptall)));
1795
1796 ctrl_columns(s, 3, 55, 20, 25);
1797 c = ctrl_text(s, "Forwarded ports:", HELPCTX(ssh_tunnels_portfwd));
1798 c->generic.column = COLUMN_FIELD(0,2);
1799 /* You want to select from the list, _then_ hit Remove. So tab order
1800 * should be that way round. */
1801 pfd = (struct portfwd_data *)ctrl_alloc(b,sizeof(struct portfwd_data));
1802 pfd->rembutton = ctrl_pushbutton(s, "Remove", 'r',
1803 HELPCTX(ssh_tunnels_portfwd),
1804 portfwd_handler, P(pfd));
1805 pfd->rembutton->generic.column = 2;
1806 pfd->rembutton->generic.tabdelay = 1;
1807 pfd->listbox = ctrl_listbox(s, NULL, NO_SHORTCUT,
1808 HELPCTX(ssh_tunnels_portfwd),
1809 portfwd_handler, P(pfd));
1810 pfd->listbox->listbox.height = 3;
1811 pfd->listbox->listbox.ncols = 2;
1812 pfd->listbox->listbox.percentages = snewn(2, int);
1813 pfd->listbox->listbox.percentages[0] = 20;
1814 pfd->listbox->listbox.percentages[1] = 80;
1815 ctrl_tabdelay(s, pfd->rembutton);
1816 ctrl_text(s, "Add new forwarded port:", HELPCTX(ssh_tunnels_portfwd));
1817 /* You want to enter source, destination and type, _then_ hit Add.
1818 * Again, we adjust the tab order to reflect this. */
1819 pfd->addbutton = ctrl_pushbutton(s, "Add", 'd',
1820 HELPCTX(ssh_tunnels_portfwd),
1821 portfwd_handler, P(pfd));
1822 pfd->addbutton->generic.column = 2;
1823 pfd->addbutton->generic.tabdelay = 1;
1824 pfd->sourcebox = ctrl_editbox(s, "Source port", 's', 40,
1825 HELPCTX(ssh_tunnels_portfwd),
1826 portfwd_handler, P(pfd), P(NULL));
1827 pfd->sourcebox->generic.column = 0;
1828 pfd->destbox = ctrl_editbox(s, "Destination", 'i', 67,
1829 HELPCTX(ssh_tunnels_portfwd),
1830 portfwd_handler, P(pfd), P(NULL));
1831 pfd->direction = ctrl_radiobuttons(s, NULL, NO_SHORTCUT, 3,
1832 HELPCTX(ssh_tunnels_portfwd),
1833 portfwd_handler, P(pfd),
1834 "Local", 'l', P(NULL),
1835 "Remote", 'm', P(NULL),
1836 "Dynamic", 'y', P(NULL),
1837 NULL);
1838 #ifndef NO_IPV6
1839 pfd->addressfamily =
1840 ctrl_radiobuttons(s, NULL, NO_SHORTCUT, 3,
1841 HELPCTX(ssh_tunnels_portfwd_ipversion),
1842 portfwd_handler, P(pfd),
1843 "Auto", 'u', I(ADDRTYPE_UNSPEC),
1844 "IPv4", '4', I(ADDRTYPE_IPV4),
1845 "IPv6", '6', I(ADDRTYPE_IPV6),
1846 NULL);
1847 #endif
1848 ctrl_tabdelay(s, pfd->addbutton);
1849 ctrl_columns(s, 1, 100);
1850
1851 if (!midsession) {
1852 /*
1853 * The Connection/SSH/Bugs panel.
1854 */
1855 ctrl_settitle(b, "Connection/SSH/Bugs",
1856 "Workarounds for SSH server bugs");
1857
1858 s = ctrl_getset(b, "Connection/SSH/Bugs", "main",
1859 "Detection of known bugs in SSH servers");
1860 ctrl_droplist(s, "Chokes on SSH-1 ignore messages", 'i', 20,
1861 HELPCTX(ssh_bugs_ignore1),
1862 sshbug_handler, I(offsetof(Config,sshbug_ignore1)));
1863 ctrl_droplist(s, "Refuses all SSH-1 password camouflage", 's', 20,
1864 HELPCTX(ssh_bugs_plainpw1),
1865 sshbug_handler, I(offsetof(Config,sshbug_plainpw1)));
1866 ctrl_droplist(s, "Chokes on SSH-1 RSA authentication", 'r', 20,
1867 HELPCTX(ssh_bugs_rsa1),
1868 sshbug_handler, I(offsetof(Config,sshbug_rsa1)));
1869 ctrl_droplist(s, "Miscomputes SSH-2 HMAC keys", 'm', 20,
1870 HELPCTX(ssh_bugs_hmac2),
1871 sshbug_handler, I(offsetof(Config,sshbug_hmac2)));
1872 ctrl_droplist(s, "Miscomputes SSH-2 encryption keys", 'e', 20,
1873 HELPCTX(ssh_bugs_derivekey2),
1874 sshbug_handler, I(offsetof(Config,sshbug_derivekey2)));
1875 ctrl_droplist(s, "Requires padding on SSH-2 RSA signatures", 'p', 20,
1876 HELPCTX(ssh_bugs_rsapad2),
1877 sshbug_handler, I(offsetof(Config,sshbug_rsapad2)));
1878 ctrl_droplist(s, "Misuses the session ID in SSH-2 PK auth", 'n', 20,
1879 HELPCTX(ssh_bugs_pksessid2),
1880 sshbug_handler, I(offsetof(Config,sshbug_pksessid2)));
1881 ctrl_droplist(s, "Handles SSH-2 key re-exchange badly", 'k', 20,
1882 HELPCTX(ssh_bugs_rekey2),
1883 sshbug_handler, I(offsetof(Config,sshbug_rekey2)));
1884 }
1885 }
1886 }
Local modifications for Simon Tatham's `PuTTY' SSH client and terminal emulator