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