ttssh2/ttxssh/fwdui.c

/*
 * Copyright (c) 1998-2001, Robert O'Callahan
 * (C) 2004- TeraTerm Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
This code is copyright (C) 1998-1999 Robert O'Callahan.
See LICENSE.TXT for the license.
*/

#include "fwdui.h"

#include "resource.h"
#include "x11util.h"
#include "util.h"
#include "dlglib.h"

#include "servicenames.h"
#include "helpid.h"

#undef DialogBoxParam
#define DialogBoxParam(p1,p2,p3,p4,p5) \
        TTDialogBoxParam(p1,p2,p3,p4,p5)
#undef EndDialog
#define EndDialog(p1,p2) \
        TTEndDialog(p1, p2)

typedef struct {
        FWDRequestSpec *spec;
        PTInstVar pvar;
} FWDEditClosure;

static void make_X_forwarding_spec(FWDRequestSpec *spec, PTInstVar pvar)
{
        spec->type = FWD_REMOTE_X11_TO_LOCAL;
        spec->from_port = -1;
        X11_get_DISPLAY_info(pvar, spec->to_host, sizeof(spec->to_host),
                             &spec->to_port, &spec->x11_screen);
        UTIL_get_lang_msg("MSG_FWD_REMOTE_XSERVER", pvar, "remote X server");
        strncpy_s(spec->from_port_name, sizeof(spec->from_port_name),
                  pvar->UIMsg, _TRUNCATE);
        UTIL_get_lang_msg("MSG_FWD_REMOTE_XSCREEN", pvar, "X server (display %d:%d)");
        _snprintf_s(spec->to_port_name, sizeof(spec->to_port_name), _TRUNCATE,
                    pvar->UIMsg, spec->to_port - 6000, spec->x11_screen);
}

static BOOL parse_request(FWDRequestSpec *request, char *str, PTInstVar pvar)
{
        char *tmp, *ch;
        int len, i, argc = 0, bracketed = 0;
        char *argv[4];
        char hostname[256];
        int start;

        if ((tmp = strchr(str, ';')) != NULL) {
                len = tmp - str;
        }
        else {
                len = strlen(str);
        }
        tmp = _malloca(sizeof(char) * (len+1));
        strncpy_s(tmp, sizeof(char) * (len+1), str, _TRUNCATE);

        if (*tmp == 'L' || *tmp == 'l') {
                request->type = FWD_LOCAL_TO_REMOTE;
        } else if (*tmp == 'R' || *tmp == 'r') {
                request->type = FWD_REMOTE_TO_LOCAL;
        } else if (*tmp == 'D' || *tmp == 'd') {
                request->type = FWD_LOCAL_DYNAMIC;
        } else if (*tmp == 'X' || *tmp == 'x') {
                make_X_forwarding_spec(request, pvar);
                return TRUE;
        } else {
                return FALSE;
        }
        tmp++;

        argv[argc++] = tmp;
        for (i=0; i<len; i++ ) {
                ch = (tmp+i);
                if (*ch == ':' && !bracketed) {
                        if (argc >= 4) {
                                argc++;
                                break;
                        }
                        *ch = '\0';
                        argv[argc++] = tmp+i+1;
                }
                else if (*ch == '[' && !bracketed) {
                        bracketed = 1;
                }
                else if (*ch == ']' && bracketed) {
                        bracketed = 0;
                }
        }

        strncpy_s(request->bind_address, sizeof(request->bind_address), "localhost", _TRUNCATE);
        i=0;
        switch (argc) {
                case 4:
                        if (*argv[i] == '\0' || strcmp(argv[i], "*") == 0) {
                                strncpy_s(request->bind_address, sizeof(request->bind_address), "0.0.0.0", _TRUNCATE);
                        }
                        else {
                                // IPv6 �A�h���X�� "[", "]" ������������
                                start = 0;
                                strncpy_s(hostname, sizeof(hostname), argv[i], _TRUNCATE);
                                if (strlen(hostname) > 0 &&
                                    hostname[strlen(hostname)-1] == ']') {
                                        hostname[strlen(hostname)-1] = '\0';
                                }
                                if (hostname[0] == '[') {
                                        start = 1;
                                }
                                strncpy_s(request->bind_address, sizeof(request->bind_address),
                                          hostname + start, _TRUNCATE);
                        }
                        i++;
                        /* don't break here */  /* Falls through. */

                case 3:
                        request->from_port = parse_port(argv[i], request->from_port_name,
                                                        sizeof(request->from_port_name));
                        if (request->from_port < 0) {
                                return FALSE;
                        }
                        i++;

                        // IPv6 �A�h���X�� "[", "]" ������������
                        start = 0;
                        strncpy_s(hostname, sizeof(hostname), argv[i], _TRUNCATE);
                        if (strlen(hostname) > 0 &&
                            hostname[strlen(hostname)-1] == ']') {
                                hostname[strlen(hostname)-1] = '\0';
                        }
                        if (hostname[0] == '[') {
                                start = 1;
                        }
                        strncpy_s(request->to_host, sizeof(request->to_host),
                                  hostname + start, _TRUNCATE);
                        i++;

                        request->to_port = parse_port(argv[i], request->to_port_name,
                                                      sizeof(request->to_port_name));
                        if (request->to_port < 0) {
                                return FALSE;
                        }

                        break;

                case 2:
                        if (request->type != FWD_LOCAL_DYNAMIC) {
                                return FALSE;
                        }
                        if (*argv[i] == '\0' || strcmp(argv[i], "*") == 0) {
                                strncpy_s(request->bind_address, sizeof(request->bind_address),
                                          "0.0.0.0", _TRUNCATE);
                        }
                        else {
                                // IPv6 �A�h���X�� "[", "]" ������������
                                start = 0;
                                strncpy_s(hostname, sizeof(hostname), argv[i], _TRUNCATE);
                                if (strlen(hostname) > 0 &&
                                    hostname[strlen(hostname)-1] == ']') {
                                        hostname[strlen(hostname)-1] = '\0';
                                }
                                if (hostname[0] == '[') {
                                        start = 1;
                                }
                                strncpy_s(request->bind_address, sizeof(request->bind_address),
                                          hostname + start, _TRUNCATE);
                        }
                        i++;
                        // FALLTHROUGH
                case 1:
                        if (request->type != FWD_LOCAL_DYNAMIC) {
                                return FALSE;
                        }
                        request->from_port = parse_port(argv[i], request->from_port_name,
                                                        sizeof(request->from_port_name));
                        if (request->from_port < 0) {
                                return FALSE;
                        }
                        i++;

                        request->to_host[0] = '\0';
                        request->to_port = parse_port("0", request->to_port_name,
                                                      sizeof(request->to_port_name));
                        break;

                default:
                        return FALSE;
        }

        return TRUE;
}

static void FWDUI_save_settings(PTInstVar pvar)
{
        int num_specs = FWD_get_num_request_specs(pvar);
        FWDRequestSpec *requests =
                (FWDRequestSpec *) malloc(sizeof(FWDRequestSpec) * num_specs);
        int i;
        char *str = pvar->settings.DefaultForwarding;
        int str_remaining = sizeof(pvar->settings.DefaultForwarding) - 1;
        char format[20];

        FWD_get_request_specs(pvar, requests, num_specs);

        *str = 0;
        str[str_remaining] = 0;

        for (i = 0; i < num_specs; i++) {
                if (str_remaining > 0 && i > 0) {
                        str[0] = ';';
                        str[1] = 0;
                        str++;
                        str_remaining--;
                }

                if (str_remaining > 0) {
                        FWDRequestSpec *spec = requests + i;
                        int chars;

                        // IPv6 �A�h���X���� "[", "]" ���t��������������
                        switch (spec->type) {
                        case FWD_LOCAL_TO_REMOTE:
                                if (strcmp(spec->bind_address,"localhost") == 0) {
                                        if (strchr(spec->to_host, ':') == NULL) {
                                                strncpy_s(format, sizeof(format), "L%s:%s:%s", _TRUNCATE);
                                        }
                                        else {
                                                strncpy_s(format, sizeof(format), "L%s:[%s]:%s", _TRUNCATE);
                                        }
                                        _snprintf_s(str, str_remaining, _TRUNCATE, format,
                                                    spec->from_port_name, spec->to_host,
                                                    spec->to_port_name);
                                }
                                else {
                                        if (strchr(spec->bind_address, ':') == NULL) {
                                                if (strchr(spec->to_host, ':') == NULL) {
                                                        strncpy_s(format, sizeof(format), "L%s:%s:%s:%s", _TRUNCATE);
                                                }
                                                else {
                                                        strncpy_s(format, sizeof(format), "L%s:%s:[%s]:%s", _TRUNCATE);
                                                }
                                        }
                                        else {
                                                if (strchr(spec->to_host, ':') == NULL) {
                                                        strncpy_s(format, sizeof(format), "L[%s]:%s:%s:%s", _TRUNCATE);
                                                }
                                                else {
                                                        strncpy_s(format, sizeof(format), "L[%s]:%s:[%s]:%s", _TRUNCATE);
                                                }
                                        }
                                        _snprintf_s(str, str_remaining, _TRUNCATE, format,
                                                    spec->bind_address, spec->from_port_name,
                                                    spec->to_host, spec->to_port_name);
                                }
                                break;
                        case FWD_REMOTE_TO_LOCAL:
                                if (strcmp(spec->bind_address,"localhost") == 0) {
                                        if (strchr(spec->to_host, ':') == NULL) {
                                                strncpy_s(format, sizeof(format), "R%s:%s:%s", _TRUNCATE);
                                        }
                                        else {
                                                strncpy_s(format, sizeof(format), "R%s:[%s]:%s", _TRUNCATE);
                                        }
                                        _snprintf_s(str, str_remaining, _TRUNCATE, format,
                                                    spec->from_port_name, spec->to_host,
                                                    spec->to_port_name);
                                }
                                else {
                                        if (strchr(spec->bind_address, ':') == NULL) {
                                                if (strchr(spec->to_host, ':') == NULL) {
                                                        strncpy_s(format, sizeof(format), "R%s:%s:%s:%s", _TRUNCATE);
                                                }
                                                else {
                                                        strncpy_s(format, sizeof(format), "R%s:%s:[%s]:%s", _TRUNCATE);
                                                }
                                        }
                                        else {
                                                if (strchr(spec->to_host, ':') == NULL) {
                                                        strncpy_s(format, sizeof(format), "R[%s]:%s:%s:%s", _TRUNCATE);
                                                }
                                                else {
                                                        strncpy_s(format, sizeof(format), "R[%s]:%s:[%s]:%s", _TRUNCATE);
                                                }
                                        }
                                        _snprintf_s(str, str_remaining, _TRUNCATE, format,
                                                    spec->bind_address, spec->from_port_name,
                                                    spec->to_host, spec->to_port_name);
                                }
                                break;
                        case FWD_REMOTE_X11_TO_LOCAL:
                                _snprintf_s(str, str_remaining, _TRUNCATE, "X");
                                break;
                        case FWD_LOCAL_DYNAMIC:
                                _snprintf_s(str, str_remaining, _TRUNCATE, "D%s:%s",
                                            spec->bind_address, spec->from_port_name);
                        }

                        chars = strlen(str);
                        str += chars;
                        str_remaining -= chars;
                }
        }

        free(requests);
}

void FWDUI_load_settings(PTInstVar pvar)
{
        char *str = pvar->settings.DefaultForwarding;

        if (str[0] != 0) {
                int i, ch, j;
                FWDRequestSpec *requests;

                j = 1;
                for (i = 0; (ch = str[i]) != 0; i++) {
                        if (ch == ';') {
                                j++;
                        }
                }

                requests =
                        (FWDRequestSpec *) malloc(sizeof(FWDRequestSpec) * j);

                j = 0;
                if (parse_request(requests, str, pvar)) {
                        j++;
                }
                for (i = 0; (ch = str[i]) != 0; i++) {
                        if (ch == ';') {
                                if (parse_request(requests + j, str + i + 1, pvar)) {
                                        j++;
                                }
                        }
                }

                qsort(requests, j, sizeof(FWDRequestSpec), FWD_compare_specs);

                for (i = 0; i < j - 1; i++) {
                        if (FWD_compare_specs(requests + i, requests + i + 1) == 0) {
                                memmove(requests + i, requests + i + 1,
                                        sizeof(FWDRequestSpec) * (j - 1 - i));
                                i--;
                                j--;
                        }
                }

                FWD_set_request_specs(pvar, requests, j);
                FWDUI_save_settings(pvar);

                free(requests);
        }
}

void FWDUI_init(PTInstVar pvar)
{
        FWDUI_load_settings(pvar);
}

void FWDUI_end(PTInstVar pvar)
{
}

void FWDUI_open(PTInstVar pvar)
{
}

static void set_verbose_port(char *buf, int bufsize, int port, char *name)
{
        char *p = name;

        while (*p && isdigit(*p)) {
                p++;
        }
        if (*p == 0) {
                strncpy_s(buf, bufsize, name, _TRUNCATE);
        }
        else {
                _snprintf_s(buf, bufsize, _TRUNCATE, "%d (%s)", port, name);
        }
}

static void get_spec_string(FWDRequestSpec *spec, char *buf,
                            int bufsize, PTInstVar pvar)
{
        char verbose_from_port[64];
        char verbose_to_port[64];

        switch (spec->type) {
        case FWD_REMOTE_TO_LOCAL:
                set_verbose_port(verbose_from_port, sizeof(verbose_from_port),
                                 spec->from_port, spec->from_port_name);
                set_verbose_port(verbose_to_port, sizeof(verbose_to_port),
                                 spec->to_port, spec->to_port_name);
                UTIL_get_lang_msg("MSG_FWD_REMOTE", pvar,
                                  "Remote \"%s\" port %s to local \"%s\" port %s");
                _snprintf_s(buf, bufsize, _TRUNCATE, pvar->UIMsg,
                            spec->bind_address, verbose_from_port,
                            spec->to_host, verbose_to_port);
                break;
        case FWD_LOCAL_TO_REMOTE:
                set_verbose_port(verbose_from_port, sizeof(verbose_from_port),
                                 spec->from_port, spec->from_port_name);
                set_verbose_port(verbose_to_port, sizeof(verbose_to_port),
                                 spec->to_port, spec->to_port_name);
                UTIL_get_lang_msg("MSG_FWD_LOCAL", pvar,
                                  "Local \"%s\" port %s to remote \"%s\" port %s");
                _snprintf_s(buf, bufsize, _TRUNCATE, pvar->UIMsg,
                            spec->bind_address, verbose_from_port,
                            spec->to_host, verbose_to_port);
                break;
        case FWD_REMOTE_X11_TO_LOCAL:
                UTIL_get_lang_msg("MSG_FWD_X", pvar,
                                  "Remote X applications to local X server");
                strncpy_s(buf, bufsize, pvar->UIMsg, _TRUNCATE);
                break;
        case FWD_LOCAL_DYNAMIC:
                set_verbose_port(verbose_from_port, sizeof(verbose_from_port),
                                 spec->from_port, spec->from_port_name);
                UTIL_get_lang_msg("MSG_FWD_DYNAMIC", pvar, "Local \"%s\" port %s to remote dynamic");
                _snprintf_s(buf, bufsize, _TRUNCATE, pvar->UIMsg,
                            spec->bind_address, verbose_from_port);
                break;
        }
}

static void update_listbox_selection(HWND dlg)
{
        HWND listbox = GetDlgItem(dlg, IDC_SSHFWDLIST);
        int cursel = SendMessage(listbox, LB_GETCURSEL, 0, 0);

        EnableWindow(GetDlgItem(dlg, IDC_EDIT), cursel >= 0);
        EnableWindow(GetDlgItem(dlg, IDC_REMOVE), cursel >= 0);
}

static void init_listbox_selection(HWND dlg)
{
        SendMessage(GetDlgItem(dlg, IDC_SSHFWDLIST), LB_SETCURSEL, 0, 0);
        update_listbox_selection(dlg);
}

static int add_spec_to_listbox(HWND dlg, FWDRequestSpec *spec, PTInstVar pvar)
{
        char buf[1024];
        HWND listbox = GetDlgItem(dlg, IDC_SSHFWDLIST);
        int index;

        get_spec_string(spec, buf, sizeof(buf), pvar);

        index = SendMessage(listbox, LB_ADDSTRING, 0, (LPARAM) buf);

        if (index >= 0) {
                FWDRequestSpec *listbox_spec = malloc(sizeof(FWDRequestSpec));

                *listbox_spec = *spec;
                if (SendMessage
                        (listbox, LB_SETITEMDATA, index,
                         (LPARAM) listbox_spec) == LB_ERR) {
                        free(listbox_spec);
                }
        }

        return index;
}

static void init_fwd_dlg(PTInstVar pvar, HWND dlg)
{
        int num_specs = FWD_get_num_request_specs(pvar);
        FWDRequestSpec *requests =
                (FWDRequestSpec *) malloc(sizeof(FWDRequestSpec) * num_specs);
        int i;
        static const DlgTextInfo text_info[] = {
                { 0, "DLG_FWD_TITLE" },
                { IDC_PORTFORWARD, "DLG_FWDSETUP_LIST" },
                { IDC_ADD, "DLG_FWDSETUP_ADD" },
                { IDC_EDIT, "DLG_FWDSETUP_EDIT" },
                { IDC_REMOVE, "DLG_FWDSETUP_REMOVE" },
                { IDC_XFORWARD, "DLG_FWDSETUP_X" },
                { IDC_SSHFWDX11, "DLG_FWDSETUP_XAPP" },
                { IDOK, "BTN_OK" },
                { IDCANCEL, "BTN_CANCEL" },
                { IDC_SSHFWDSETUP_HELP, "BTN_HELP" },
        };
        SetI18nDlgStrsW(dlg, "TTSSH", text_info, _countof(text_info), pvar->ts->UILanguageFileW);

        FWD_get_request_specs(pvar, requests, num_specs);

        for (i = 0; i < num_specs; i++) {
                if (requests[i].type == FWD_REMOTE_X11_TO_LOCAL) {
                        CheckDlgButton(dlg, IDC_SSHFWDX11, TRUE);
                } else {
                        add_spec_to_listbox(dlg, requests + i, pvar);
                }
        }

        free(requests);

        init_listbox_selection(dlg);
}

static void free_listbox_spec(HWND listbox, int selection)
{
        FWDRequestSpec *spec = (FWDRequestSpec *)
                SendMessage(listbox, LB_GETITEMDATA, selection, 0);

        if (spec != NULL) {
                free(spec);
        }
}

static void free_all_listbox_specs(HWND dlg)
{
        HWND listbox = GetDlgItem(dlg, IDC_SSHFWDLIST);
        int i;

        for (i = SendMessage(listbox, LB_GETCOUNT, 0, 0) - 1; i >= 0; i--) {
                free_listbox_spec(listbox, i);
        }
}

static BOOL end_fwd_dlg(PTInstVar pvar, HWND dlg)
{
        char buf[1024];
        HWND listbox = GetDlgItem(dlg, IDC_SSHFWDLIST);
        int num_items = SendMessage(listbox, LB_GETCOUNT, 0, 0);
        BOOL X_enabled = IsDlgButtonChecked(dlg, IDC_SSHFWDX11);
        int num_specs = X_enabled ? 1 : 0;
        FWDRequestSpec *specs =
                (FWDRequestSpec *) malloc(sizeof(FWDRequestSpec) * (num_specs + num_items));
        int i;
        int num_unspecified_forwardings = 0;

        for (i = 0; i < num_items; i++) {
                FWDRequestSpec *spec = (FWDRequestSpec *)
                        SendMessage(listbox, LB_GETITEMDATA, i, 0);

                if (spec != NULL) {
                        specs[num_specs] = *spec;
                        num_specs++;
                }
        }

        if (X_enabled) {
                make_X_forwarding_spec(specs, pvar);
        }

        qsort(specs, num_specs, sizeof(FWDRequestSpec), FWD_compare_specs);

        buf[0] = '\0';
        for (i = 0; i < num_specs; i++) {
                if (i < num_specs - 1 && FWD_compare_specs(specs + i, specs + i + 1) == 0) {
                        switch (specs[i].type) {
                        case FWD_REMOTE_TO_LOCAL:
                                UTIL_get_lang_msg("MSG_SAME_SERVERPORT_ERROR", pvar,
                                                  "You cannot have two forwarding from the same server port (%d).");
                                _snprintf_s(buf, sizeof(buf), _TRUNCATE,
                                            pvar->UIMsg, specs[i].from_port);
                                break;
                        case FWD_LOCAL_TO_REMOTE:
                        case FWD_LOCAL_DYNAMIC:
                                UTIL_get_lang_msg("MSG_SAME_LOCALPORT_ERROR", pvar,
                                                  "You cannot have two forwarding from the same local port (%d).");
                                _snprintf_s(buf, sizeof(buf), _TRUNCATE,
                                            pvar->UIMsg, specs[i].from_port);
                                break;
                        }
                        notify_nonfatal_error(pvar, buf);

                        free(specs);
                        return FALSE;
                }

                if (!FWD_can_server_listen_for(pvar, specs + i)) {
                        num_unspecified_forwardings++;
                }
        }

        if (num_unspecified_forwardings > 0) {
                UTIL_get_lang_msg("MSG_UNSPECIFIED_FWD_ERROR1", pvar,
                                  "The following forwarding was not specified when this SSH session began:\n\n");
                strncat_s(buf, sizeof(buf), pvar->UIMsg, _TRUNCATE);

                for (i = 0; i < num_specs; i++) {
                        if (!FWD_can_server_listen_for(pvar, specs + i)) {
                                char buf2[1024];

                                get_spec_string(specs + i, buf2, sizeof(buf2), pvar);

                                strncat_s(buf, sizeof(buf), buf2, _TRUNCATE);
                                strncat_s(buf, sizeof(buf), "\n", _TRUNCATE);
                        }
                }

                UTIL_get_lang_msg("MSG_UNSPECIFIED_FWD_ERROR2", pvar,
                                  "\nDue to a limitation of the SSH protocol, this forwarding will not work in the current SSH session.\n"
                                  "If you save these settings and start a new SSH session, the forwarding should work.");
                strncat_s(buf, sizeof(buf), pvar->UIMsg, _TRUNCATE);

                notify_nonfatal_error(pvar, buf);
        }

        FWD_set_request_specs(pvar, specs, num_specs);
        FWDUI_save_settings(pvar);
        free_all_listbox_specs(dlg);
        EndDialog(dlg, 1);

        free(specs);

        return TRUE;
}

static void fill_service_names(HWND dlg, WORD item)
{
        HWND cbox = GetDlgItem(dlg, item);
        int i;
        char *svc;

        for (i=0; (svc = service_name(i)) != NULL; i++) {
                SendMessage(cbox, CB_ADDSTRING, 0, (LPARAM) svc);
        }
}

static void init_input(HWND dlg, FWDType type_to)
{
        HWND dlg_item;

        if (type_to == FWD_REMOTE_TO_LOCAL || type_to == FWD_LOCAL_DYNAMIC) {
                dlg_item = GetDlgItem(dlg, IDC_SSHLTRFROMPORT);
                EnableWindow(dlg_item, FALSE);
                dlg_item = GetDlgItem(dlg, IDC_SSHLTRLISTENADDR);
                EnableWindow(dlg_item, FALSE);
                dlg_item = GetDlgItem(dlg, IDC_SSHLTRTOHOST);
                EnableWindow(dlg_item, FALSE);
                dlg_item = GetDlgItem(dlg, IDC_SSHLTRTOPORT);
                EnableWindow(dlg_item, FALSE);
        }
        if (type_to == FWD_LOCAL_TO_REMOTE || type_to == FWD_LOCAL_DYNAMIC) {
                dlg_item = GetDlgItem(dlg, IDC_SSHRTLFROMPORT);
                EnableWindow(dlg_item, FALSE);
                dlg_item = GetDlgItem(dlg, IDC_SSHRTLLISTENADDR);
                EnableWindow(dlg_item, FALSE);
                dlg_item = GetDlgItem(dlg, IDC_SSHRTLTOHOST);
                EnableWindow(dlg_item, FALSE);
                dlg_item = GetDlgItem(dlg, IDC_SSHRTLTOPORT);
                EnableWindow(dlg_item, FALSE);
        }
        if (type_to == FWD_REMOTE_TO_LOCAL || type_to == FWD_LOCAL_TO_REMOTE) {
                dlg_item = GetDlgItem(dlg, IDC_SSHDYNFROMPORT);
                EnableWindow(dlg_item, FALSE);
                dlg_item = GetDlgItem(dlg, IDC_SSHDYNLISTENADDR);
                EnableWindow(dlg_item, FALSE);
        }
}

static void shift_over_input(HWND dlg, FWDType type_from, FWDType type_to,
                             WORD rtl_item, WORD ltr_item, WORD dyn_item)
{
        HWND shift_from = NULL;
        HWND shift_to = NULL;

        if (type_from == FWD_LOCAL_TO_REMOTE ) {
                shift_from = GetDlgItem(dlg, ltr_item);
        }
        else if (type_from == FWD_REMOTE_TO_LOCAL) {
                shift_from = GetDlgItem(dlg, rtl_item);
        }
        else if (type_from == FWD_LOCAL_DYNAMIC && dyn_item != 0) {
                shift_from = GetDlgItem(dlg, dyn_item);
        }

        if (type_to == FWD_LOCAL_TO_REMOTE ) {
                shift_to = GetDlgItem(dlg, ltr_item);
        }
        else if (type_to == FWD_REMOTE_TO_LOCAL) {
                shift_to = GetDlgItem(dlg, rtl_item);
        }
        else if (type_to == FWD_LOCAL_DYNAMIC && dyn_item != 0) {
                shift_to = GetDlgItem(dlg, dyn_item);
        }

        if (shift_from != 0) {
                EnableWindow(shift_from, FALSE);
        }
        if (shift_to != 0) {
                EnableWindow(shift_to, TRUE);
        }

        if (shift_from != 0 && shift_to != 0 && GetWindowTextLength(shift_to) == 0) {
                char buf[128];

                GetWindowText(shift_from, buf, sizeof(buf));
                buf[sizeof(buf) - 1] = 0;
                SetWindowText(shift_to, buf);
                SetWindowText(shift_from, "");
        }
}

static void set_dir_options_status(HWND dlg)
{
        FWDType type_to, type_from;
        BOOL enable_LTR, enable_RTL, enable_DYN;

        type_to = FWD_REMOTE_TO_LOCAL;
        if (IsDlgButtonChecked(dlg, IDC_SSHFWDLOCALTOREMOTE)) {
                type_to = FWD_LOCAL_TO_REMOTE;
        }
        if (IsDlgButtonChecked(dlg, IDC_SSHFWDLOCALDYNAMIC)) {
                type_to = FWD_LOCAL_DYNAMIC;
        }

        enable_LTR = IsWindowEnabled(GetDlgItem(dlg, IDC_SSHLTRFROMPORT));
        enable_RTL = IsWindowEnabled(GetDlgItem(dlg, IDC_SSHRTLFROMPORT));
        enable_DYN = IsWindowEnabled(GetDlgItem(dlg, IDC_SSHDYNFROMPORT));
        type_from = FWD_NONE; // �_�C�A���O�\��������������Enable����
        if (enable_LTR && !enable_RTL && !enable_DYN) {
                type_from = FWD_LOCAL_TO_REMOTE;
        }
        else if (!enable_LTR && enable_RTL && !enable_DYN) {
                type_from = FWD_REMOTE_TO_LOCAL;
        }
        else if (!enable_LTR && !enable_RTL && enable_DYN) {
                type_from = FWD_LOCAL_DYNAMIC;
        }

        if (type_from == FWD_NONE) {
                init_input(dlg, type_to);
        }
        else {
                shift_over_input(dlg, type_from, type_to, IDC_SSHRTLFROMPORT, IDC_SSHLTRFROMPORT, IDC_SSHDYNFROMPORT);
                shift_over_input(dlg, type_from, type_to, IDC_SSHRTLLISTENADDR, IDC_SSHLTRLISTENADDR, IDC_SSHDYNLISTENADDR);
                shift_over_input(dlg, type_from, type_to, IDC_SSHRTLTOHOST, IDC_SSHLTRTOHOST, 0);
                shift_over_input(dlg, type_from, type_to, IDC_SSHRTLTOPORT, IDC_SSHLTRTOPORT, 0);
        }
}

static void setup_edit_controls(HWND dlg, FWDRequestSpec *spec,
                                WORD radio_item,
                                WORD from_port_item, WORD listen_address_item,
                                WORD to_host_item, WORD to_port_item)
{
        CheckDlgButton(dlg, radio_item, TRUE);
        SetFocus(GetDlgItem(dlg, radio_item));
        SetDlgItemText(dlg, from_port_item, spec->from_port_name);
        if (to_port_item != 0) {
                SetDlgItemText(dlg, to_port_item, spec->to_port_name);
        }
        if (to_host_item != 0 && strcmp(spec->to_host, "localhost") != 0) {
                SetDlgItemText(dlg, to_host_item, spec->to_host);
        }
        if (strcmp(spec->bind_address, "localhost") != 0) {
                SetDlgItemText(dlg, listen_address_item, spec->bind_address);
        }

        set_dir_options_status(dlg);
}

static void init_fwd_edit_dlg(PTInstVar pvar, FWDRequestSpec *spec, HWND dlg)
{
        static const DlgTextInfo text_info[] = {
                { 0, "DLG_FWD_TITLE" },
                { IDD_SSHFWDBANNER, "DLG_FWD_BANNER" },
                { IDC_SSHFWDLOCALTOREMOTE, "DLG_FWD_LOCAL_PORT" },
                { IDC_SSHFWDLOCALTOREMOTE_LISTEN, "DLG_FWD_LOCAL_LISTEN" },
                { IDC_SSHFWDLOCALTOREMOTE_HOST, "DLG_FWD_LOCAL_REMOTE" },
                { IDC_SSHFWDLOCALTOREMOTE_PORT, "DLG_FWD_LOCAL_REMOTE_PORT" },
                { IDC_SSHFWDREMOTETOLOCAL, "DLG_FWD_REMOTE_PORT" },
                { IDC_SSHFWDREMOTETOLOCAL_LISTEN, "DLG_FWD_REMOTE_LISTEN" },
                { IDC_SSHFWDREMOTETOLOCAL_HOST, "DLG_FWD_REMOTE_LOCAL" },
                { IDC_SSHFWDREMOTETOLOCAL_PORT, "DLG_FWD_REMOTE_LOCAL_PORT" },
                { IDC_SSHFWDLOCALDYNAMIC, "DLG_FWD_DYNAMIC_PORT" },
                { IDC_SSHFWDLOCALDYNAMIC_LISTEN, "DLG_FWD_DYNAMIC_LISTEN" },
                { IDOK, "BTN_OK" },
                { IDCANCEL, "BTN_CANCEL" },
        };
        SetI18nDlgStrsW(dlg, "TTSSH", text_info, _countof(text_info), pvar->ts->UILanguageFileW);

        switch (spec->type) {
        case FWD_REMOTE_TO_LOCAL:
                setup_edit_controls(dlg, spec, IDC_SSHFWDREMOTETOLOCAL,
                                    IDC_SSHRTLFROMPORT, IDC_SSHRTLLISTENADDR,
                                    IDC_SSHRTLTOHOST, IDC_SSHRTLTOPORT);
                break;
        case FWD_LOCAL_TO_REMOTE:
                setup_edit_controls(dlg, spec, IDC_SSHFWDLOCALTOREMOTE,
                                    IDC_SSHLTRFROMPORT, IDC_SSHLTRLISTENADDR,
                                    IDC_SSHLTRTOHOST, IDC_SSHLTRTOPORT);
                break;
        case FWD_LOCAL_DYNAMIC:
                setup_edit_controls(dlg, spec, IDC_SSHFWDLOCALDYNAMIC,
                                    IDC_SSHDYNFROMPORT, IDC_SSHDYNLISTENADDR,
                                    0, 0);
                break;
        }

        fill_service_names(dlg, IDC_SSHRTLFROMPORT);
        fill_service_names(dlg, IDC_SSHLTRFROMPORT);
        fill_service_names(dlg, IDC_SSHRTLTOPORT);
        fill_service_names(dlg, IDC_SSHLTRTOPORT);
}

static void grab_control_text(HWND dlg, FWDType type,
                              WORD rtl_item, WORD ltr_item, WORD dyn_item,
                              char *buf, int bufsize)
{
        WORD dlg_item = ltr_item;
        if (type == FWD_REMOTE_TO_LOCAL) {
                dlg_item = rtl_item;
        }
        else if (type == FWD_LOCAL_DYNAMIC) {
                dlg_item = dyn_item;
        }

        GetDlgItemText(dlg, dlg_item, buf, bufsize);
        buf[bufsize - 1] = 0;
}

static BOOL end_fwd_edit_dlg(PTInstVar pvar, FWDRequestSpec *spec, HWND dlg)
{
        FWDRequestSpec new_spec;
        FWDType type;
        char buf[1024];

        type = FWD_LOCAL_TO_REMOTE;
        if (IsDlgButtonChecked(dlg, IDC_SSHFWDREMOTETOLOCAL)) {
                type = FWD_REMOTE_TO_LOCAL;
        }
        else if (IsDlgButtonChecked(dlg, IDC_SSHFWDLOCALDYNAMIC)) {
                type = FWD_LOCAL_DYNAMIC;
        }
        new_spec.type = type;

        grab_control_text(dlg, type,
                          IDC_SSHRTLFROMPORT, IDC_SSHLTRFROMPORT, IDC_SSHDYNFROMPORT,
                          new_spec.from_port_name, sizeof(new_spec.from_port_name));

        grab_control_text(dlg, type,
                          IDC_SSHRTLLISTENADDR, IDC_SSHLTRLISTENADDR, IDC_SSHDYNLISTENADDR,
                          new_spec.bind_address, sizeof(new_spec.bind_address));
        if (new_spec.bind_address[0] == 0) {
                strncpy_s(new_spec.bind_address, sizeof(new_spec.bind_address), "localhost", _TRUNCATE);
        }
        else if (strcmp(new_spec.bind_address, "*") == 0 ) {
                strncpy_s(new_spec.bind_address, sizeof(new_spec.bind_address), "0.0.0.0", _TRUNCATE);
        }
        else {
                // IPv6 �A�h���X�� "[", "]" ������������
                if (new_spec.bind_address[strlen(new_spec.bind_address)-1] == ']') {
                        new_spec.bind_address[strlen(new_spec.bind_address)-1] = '\0';
                }
                if (new_spec.bind_address[0] == '[') {
                        memmove(new_spec.bind_address, new_spec.bind_address + 1, strlen(new_spec.bind_address)+1);
                }
        }

        if (type == FWD_LOCAL_TO_REMOTE || type == FWD_REMOTE_TO_LOCAL) {
                grab_control_text(dlg, type,
                                  IDC_SSHRTLTOHOST, IDC_SSHLTRTOHOST, 0,
                                  new_spec.to_host, sizeof(new_spec.to_host));
                if (new_spec.to_host[0] == 0) {
                        strncpy_s(new_spec.to_host, sizeof(new_spec.to_host), "localhost", _TRUNCATE);
                }
                else {
                        // IPv6 �A�h���X�� "[", "]" ������������
                        if (new_spec.to_host[strlen(new_spec.to_host)-1] == ']') {
                                new_spec.to_host[strlen(new_spec.to_host)-1] = '\0';
                        }
                        if (new_spec.to_host[0] == '[') {
                                memmove(new_spec.to_host, new_spec.to_host + 1, strlen(new_spec.to_host)+1);
                        }
                }

                grab_control_text(dlg, type,
                                  IDC_SSHRTLTOPORT, IDC_SSHLTRTOPORT, 0,
                                  new_spec.to_port_name, sizeof(new_spec.to_port_name));
        }

        new_spec.from_port = parse_port_from_buf(new_spec.from_port_name);
        if (new_spec.from_port < 0) {
                UTIL_get_lang_msg("MSG_INVALID_PORT_ERROR", pvar,
                                  "Port \"%s\" is not a valid port number.\n"
                                  "Either choose a port name from the list, or enter a number between 1 and 65535.");
                _snprintf_s(buf, sizeof(buf), _TRUNCATE,
                            pvar->UIMsg, new_spec.from_port_name);
                notify_nonfatal_error(pvar, buf);
                return FALSE;
        }

        if (type == FWD_LOCAL_TO_REMOTE || type == FWD_REMOTE_TO_LOCAL) {
                new_spec.to_port = parse_port_from_buf(new_spec.to_port_name);
                if (new_spec.to_port < 0) {
                        UTIL_get_lang_msg("MSG_INVALID_PORT_ERROR", pvar,
                                          "Port \"%s\" is not a valid port number.\n"
                                          "Either choose a port name from the list, or enter a number between 1 and 65535.");
                        _snprintf_s(buf, sizeof(buf), _TRUNCATE,
                                    pvar->UIMsg, new_spec.to_port_name);
                        notify_nonfatal_error(pvar, buf);
                        return FALSE;
                }
        }

        *spec = new_spec;

        EndDialog(dlg, 1);
        return TRUE;
}

static INT_PTR CALLBACK fwd_edit_dlg_proc(HWND dlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
        FWDEditClosure *closure;
        PTInstVar pvar;
        BOOL result;

        switch (msg) {
        case WM_INITDIALOG:
                closure = (FWDEditClosure *) lParam;
                SetWindowLongPtr(dlg, DWLP_USER, lParam);

                pvar = closure->pvar;
                init_fwd_edit_dlg(pvar, closure->spec, dlg);
                CenterWindow(dlg, GetParent(dlg));
                return FALSE;                   /* because we set the focus */

        case WM_COMMAND:
                closure = (FWDEditClosure *) GetWindowLongPtr(dlg, DWLP_USER);

                switch (LOWORD(wParam)) {
                case IDOK:

                        result = end_fwd_edit_dlg(closure->pvar, closure->spec, dlg);

                        if (result) {
                        }

                        return result;

                case IDCANCEL:
                        EndDialog(dlg, 0);
                        return TRUE;

                case IDC_SSHFWDLOCALTOREMOTE:
                case IDC_SSHFWDREMOTETOLOCAL:
                case IDC_SSHFWDLOCALDYNAMIC:
                        set_dir_options_status(dlg);
                        return TRUE;

                default:
                        return FALSE;
                }

        default:
                return FALSE;
        }
}

static void add_forwarding_entry(PTInstVar pvar, HWND dlg)
{
        FWDRequestSpec new_spec;
        INT_PTR result;
        FWDEditClosure closure = { &new_spec, pvar };

        new_spec.type = FWD_LOCAL_TO_REMOTE;
        new_spec.from_port_name[0] = 0;
        new_spec.bind_address[0] = 0;
        new_spec.to_host[0] = 0;
        new_spec.to_port_name[0] = 0;

        result = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SSHFWDEDIT),
                                dlg, fwd_edit_dlg_proc, (LPARAM) & closure);

        if (result == -1) {
                UTIL_get_lang_msg("MSG_CREATEWINDOW_FWDEDIT_ERROR", pvar,
                                  "Unable to display forwarding edit dialog box.");
                notify_nonfatal_error(pvar, pvar->UIMsg);
        } else if (result) {
                int index = add_spec_to_listbox(dlg, &new_spec, pvar);

                if (index >= 0) {
                        SendMessage(GetDlgItem(dlg, IDC_SSHFWDLIST), LB_SETCURSEL,
                                    index, 0);
                }
                update_listbox_selection(dlg);
        }
}

static void edit_forwarding_entry(PTInstVar pvar, HWND dlg)
{
        HWND listbox = GetDlgItem(dlg, IDC_SSHFWDLIST);
        int cursel = SendMessage(listbox, LB_GETCURSEL, 0, 0);

        if (cursel >= 0) {
                FWDRequestSpec *spec = (FWDRequestSpec *)
                        SendMessage(listbox, LB_GETITEMDATA, cursel, 0);

                if (spec != NULL) {
                        FWDEditClosure closure = { spec, pvar };

                        INT_PTR result =
                                DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SSHFWDEDIT),
                                               dlg, fwd_edit_dlg_proc, (LPARAM) & closure);

                        if (result == -1) {
                                UTIL_get_lang_msg("MSG_CREATEWINDOW_FWDEDIT_ERROR", pvar,
                                                  "Unable to display forwarding edit dialog box.");
                                notify_nonfatal_error(pvar, pvar->UIMsg);
                        } else if (result) {
                                SendMessage(listbox, LB_DELETESTRING, cursel, 0);

                                cursel = add_spec_to_listbox(dlg, spec, pvar);
                                free(spec);
                                if (cursel >= 0) {
                                        SendMessage(GetDlgItem(dlg, IDC_SSHFWDLIST),
                                                    LB_SETCURSEL, cursel, 0);
                                }
                                update_listbox_selection(dlg);
                        }
                }
        }
}

static void remove_forwarding_entry(HWND dlg)
{
        HWND listbox = GetDlgItem(dlg, IDC_SSHFWDLIST);
        int cursel = SendMessage(listbox, LB_GETCURSEL, 0, 0);

        if (cursel >= 0) {
                free_listbox_spec(listbox, cursel);
                SendMessage(listbox, LB_DELETESTRING, cursel, 0);
                init_listbox_selection(dlg);
        }
}

static INT_PTR CALLBACK fwd_dlg_proc(HWND dlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
        PTInstVar pvar;
        BOOL ret;

        switch (msg) {
        case WM_INITDIALOG:
                pvar = (PTInstVar) lParam;
                SetWindowLongPtr(dlg, DWLP_USER, lParam);

                init_fwd_dlg(pvar, dlg);
                CenterWindow(dlg, GetParent(dlg));
                return TRUE;                    /* because we do not set the focus */

        case WM_COMMAND:
                pvar = (PTInstVar) GetWindowLongPtr(dlg, DWLP_USER);

                switch (LOWORD(wParam)) {
                case IDOK:

                        ret = end_fwd_dlg(pvar, dlg);
                        return ret;

                case IDCANCEL:
                        free_all_listbox_specs(dlg);
                        EndDialog(dlg, 0);
                        return TRUE;

                case IDC_SSHFWDSETUP_HELP:
                        PostMessage(GetParent(dlg), WM_USER_DLGHELP2, HlpMenuSetupSshforward, 0);
                        return TRUE;

                case IDC_ADD:
                        add_forwarding_entry(pvar, dlg);
                        return TRUE;

                case IDC_EDIT:
                        edit_forwarding_entry(pvar, dlg);
                        return TRUE;

                case IDC_REMOVE:
                        remove_forwarding_entry(dlg);
                        return TRUE;

                case IDC_SSHFWDLIST:
                        update_listbox_selection(dlg);
                        return TRUE;

                default:
                        return FALSE;
                }

        default:
                return FALSE;
        }
}

void FWDUI_do_forwarding_dialog(PTInstVar pvar)
{
        HWND cur_active = GetActiveWindow();

        if (DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SSHFWDSETUP),
                               cur_active != NULL ? cur_active
                                                  : pvar->NotificationWindow,
                               fwd_dlg_proc, (LPARAM) pvar) == -1) {
                UTIL_get_lang_msg("MSG_CREATEWINDOW_FWDSETUP_ERROR", pvar,
                                  "Unable to display forwarding setup dialog box.");
                notify_nonfatal_error(pvar, pvar->UIMsg);
        }
}

/* vim: set ts=4 sw=4 ff=dos : */