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