ttssh2/ttxssh/ttxssh.c

/*
Copyright (c) 1998-2001, Robert O'Callahan
All rights reserved.

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of
conditions and the following disclaimer.

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.

The name of Robert O'Callahan may not be used to endorse or promote products derived from
this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.
*/

/* Tera Term extension mechanism
   Robert O'Callahan (roc+tt@cs.cmu.edu)

   Tera Term by Takashi Teranishi (teranishi@rikaxp.riken.go.jp)
*/

#include "ttxssh.h"
#include "fwdui.h"
#include "util.h"
#include "ssh.h"
#include "ttcommon.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <io.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <time.h>

#include "resource.h"
#include <commctrl.h>
#include <commdlg.h>
#ifndef NO_INET6
#include <winsock2.h>
static char FAR *ProtocolFamilyList[] = { "UNSPEC", "IPv6", "IPv4", NULL };
#else
#include <winsock.h>
#endif                                                  /* NO_INET6 */

#include <Lmcons.h>

// include OpenSSL header file
#include <openssl/opensslv.h>
#include <openssl/evp.h>
#include <openssl/rsa.h>
#include <openssl/dsa.h>
#include <openssl/bn.h>
#include <openssl/pem.h>
#include <openssl/rand.h>
#include <openssl/rc4.h>
#include <openssl/md5.h>

// include ZLib header file
#include <zlib.h>

#include "buffer.h"
#include "cipher.h"

#include "sftp.h"

#include "compat_w95.h"

#define MATCH_STR(s, o) strncmp((s), (o), NUM_ELEM(o) - 1)
#define MATCH_STR_I(s, o) _strnicmp((s), (o), NUM_ELEM(o) - 1)

/* This extension implements SSH, so we choose a load order in the
   "protocols" range. */
#define ORDER 2500

static HICON SecureLargeIcon = NULL;
static HICON SecureSmallIcon = NULL;

static HFONT DlgHostFont;
static HFONT DlgAboutFont;
static HFONT DlgSetupFont;
static HFONT DlgKeygenFont;

static TInstVar FAR *pvar;

typedef struct {
        int     cnt;
        HWND    dlg;
        enum hostkey_type type;
} cbarg_t;

  /* WIN32 allows multiple instances of a DLL */
static TInstVar InstVar;

/*
This code makes lots of assumptions about the order in which Tera Term
does things, and how. A key assumption is that the Notification window
passed into WSAAsyncSelect is the main terminal window. We also assume
that the socket used in the first WSAconnect is the main session socket.
*/

static void init_TTSSH(PTInstVar pvar)
{
        pvar->socket = INVALID_SOCKET;
        pvar->OldLargeIcon = NULL;
        pvar->OldSmallIcon = NULL;
        pvar->NotificationWindow = NULL;
        pvar->hostdlg_activated = FALSE;
        pvar->socket = INVALID_SOCKET;
        pvar->NotificationWindow = NULL;
        pvar->protocol_major = 0;
        pvar->protocol_minor = 0;

        PKT_init(pvar);
        SSH_init(pvar);
        CRYPT_init(pvar);
        AUTH_init(pvar);
        HOSTS_init(pvar);
        FWD_init(pvar);
        FWDUI_init(pvar);

        ssh_heartbeat_lock_initialize();
}

static void uninit_TTSSH(PTInstVar pvar)
{
        halt_ssh_heartbeat_thread(pvar);

        ssh2_channel_free();

        SSH_end(pvar);
        PKT_end(pvar);
        AUTH_end(pvar);
        CRYPT_end(pvar);
        HOSTS_end(pvar);
        FWD_end(pvar);
        FWDUI_end(pvar);

        if (pvar->OldLargeIcon != NULL) {
                PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_BIG,
                            (LPARAM) pvar->OldLargeIcon);
                pvar->OldLargeIcon = NULL;
        }
        if (pvar->OldSmallIcon != NULL) {
                PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_SMALL,
                            (LPARAM) pvar->OldSmallIcon);
                pvar->OldSmallIcon = NULL;
        }

        ssh_heartbeat_lock_finalize();
}

static void PASCAL FAR TTXInit(PTTSet ts, PComVar cv)
{
        pvar->settings = *pvar->ts_SSH;
        pvar->ts = ts;
        pvar->cv = cv;
        pvar->fatal_error = FALSE;
        pvar->showing_err = FALSE;
        pvar->err_msg = NULL;

        init_TTSSH(pvar);
}

/*
 * Remove unsupported cipher or duplicated cipher.
 * Add unspecified ciphers at the end of list.
 */
static void normalize_cipher_order(char FAR * buf)
{
        char ciphers_listed[SSH_CIPHER_MAX + 1];
        char ciphers_allowed[SSH_CIPHER_MAX + 1];
        int i, j;

        /* SSH_CIPHER_NONE means that all ciphers below that one are disabled.
           We *never* allow no encryption. */
#if 0
        static char default_ciphers[] = {
                SSH_CIPHER_3DES,
                SSH_CIPHER_NONE,
                SSH_CIPHER_DES, SSH_CIPHER_BLOWFISH
        };
#else
        // for SSH2(yutaka)
        static char default_ciphers[] = {
                SSH2_CIPHER_AES256_CTR,
                SSH2_CIPHER_AES256_CBC,
                SSH2_CIPHER_AES192_CTR,
                SSH2_CIPHER_AES192_CBC,
                SSH2_CIPHER_AES128_CTR,
                SSH2_CIPHER_AES128_CBC,
                SSH2_CIPHER_3DES_CBC,
                SSH2_CIPHER_BLOWFISH_CBC,
                SSH2_CIPHER_ARCFOUR256,
                SSH2_CIPHER_ARCFOUR128,
                SSH2_CIPHER_ARCFOUR,
                SSH2_CIPHER_CAST128_CBC,
                SSH_CIPHER_3DES,
                SSH_CIPHER_NONE,
                SSH_CIPHER_DES,
                SSH_CIPHER_BLOWFISH
        };
#endif

        memset(ciphers_listed, 0, sizeof(ciphers_listed));

        memset(ciphers_allowed, 0, sizeof(ciphers_allowed));
        for (i = 0; i < NUM_ELEM(default_ciphers); i++) {
                ciphers_allowed[default_ciphers[i]] = 1;
        }

        for (i = 0; buf[i] != 0; i++) {
                int cipher_num = buf[i] - '0';

                if (cipher_num < 0 || cipher_num > SSH_CIPHER_MAX
                        || !ciphers_allowed[cipher_num]
                        || ciphers_listed[cipher_num]) {
                        memmove(buf + i, buf + i + 1, strlen(buf + i + 1) + 1);
                        i--;
                } else {
                        ciphers_listed[cipher_num] = 1;
                }
        }

        for (j = 0; j < NUM_ELEM(default_ciphers); j++) {
                int cipher_num = default_ciphers[j];

                if (!ciphers_listed[cipher_num]) {
                        buf[i] = cipher_num + '0';
                        i++;
                }
        }

        buf[i] = 0;
}

/* Remove local settings from the shared memory block. */
static void clear_local_settings(PTInstVar pvar)
{
        pvar->ts_SSH->TryDefaultAuth = FALSE;
}

static BOOL read_BOOL_option(PCHAR fileName, char FAR * keyName, BOOL def)
{
        char buf[1024];

        buf[0] = 0;
        GetPrivateProfileString("TTSSH", keyName, "", buf, sizeof(buf),
                                fileName);
        if (buf[0] == 0) {
                return def;
        } else {
                return atoi(buf) != 0 ||
                       _stricmp(buf, "yes") == 0 ||
                       _stricmp(buf, "y") == 0;
        }
}

static void read_string_option(PCHAR fileName, char FAR * keyName,
                               char FAR * def, char FAR * buf, int bufSize)
{

        buf[0] = 0;
        GetPrivateProfileString("TTSSH", keyName, def, buf, bufSize, fileName);
}

static void read_ssh_options(PTInstVar pvar, PCHAR fileName)
{
        char buf[1024];
        TS_SSH FAR *settings = pvar->ts_SSH;

#define READ_STD_STRING_OPTION(name) \
        read_string_option(fileName, #name, "", settings->name, sizeof(settings->name))

        settings->Enabled = read_BOOL_option(fileName, "Enabled", FALSE);

        buf[0] = 0;
        GetPrivateProfileString("TTSSH", "Compression", "", buf, sizeof(buf),
                                fileName);
        settings->CompressionLevel = atoi(buf);
        if (settings->CompressionLevel < 0 || settings->CompressionLevel > 9) {
                settings->CompressionLevel = 0;
        }

        READ_STD_STRING_OPTION(DefaultUserName);
        READ_STD_STRING_OPTION(DefaultForwarding);
        READ_STD_STRING_OPTION(DefaultRhostsLocalUserName);
        READ_STD_STRING_OPTION(DefaultRhostsHostPrivateKeyFile);
        READ_STD_STRING_OPTION(DefaultRSAPrivateKeyFile);

        READ_STD_STRING_OPTION(CipherOrder);
        normalize_cipher_order(settings->CipherOrder);

        read_string_option(fileName, "KnownHostsFiles", "ssh_known_hosts",
                           settings->KnownHostsFiles,
                           sizeof(settings->KnownHostsFiles));

        buf[0] = 0;
        GetPrivateProfileString("TTSSH", "DefaultAuthMethod", "", buf,
                                sizeof(buf), fileName);
        settings->DefaultAuthMethod = atoi(buf);
        if (settings->DefaultAuthMethod != SSH_AUTH_PASSWORD
         && settings->DefaultAuthMethod != SSH_AUTH_RSA
         && settings->DefaultAuthMethod != SSH_AUTH_TIS  // add (2005.3.12 yutaka)
         && settings->DefaultAuthMethod != SSH_AUTH_RHOSTS
         && settings->DefaultAuthMethod != SSH_AUTH_PAGEANT) {
                /* this default can never be SSH_AUTH_RHOSTS_RSA because that is not a
                   selection in the dialog box; SSH_AUTH_RHOSTS_RSA is automatically chosen
                   when the dialog box has rhosts selected and an host private key file
                   is supplied. */
                settings->DefaultAuthMethod = SSH_AUTH_PASSWORD;
        }

        buf[0] = 0;
        GetPrivateProfileString("TTSSH", "LogLevel", "", buf, sizeof(buf),
                                fileName);
        settings->LogLevel = atoi(buf);

        buf[0] = 0;
        GetPrivateProfileString("TTSSH", "WriteBufferSize", "", buf,
                                sizeof(buf), fileName);
        settings->WriteBufferSize = atoi(buf);
        if (settings->WriteBufferSize <= 0) {
                settings->WriteBufferSize = (PACKET_MAX_SIZE / 2);   // 2MB
        }

        settings->LocalForwardingIdentityCheck =
                read_BOOL_option(fileName, "LocalForwardingIdentityCheck", TRUE);

        // SSH protocol version (2004.10.11 yutaka)
        // default is SSH2 (2004.11.30 yutaka)
        settings->ssh_protocol_version = GetPrivateProfileInt("TTSSH", "ProtocolVersion", 2, fileName);

        // SSH heartbeat time(second) (2004.12.11 yutaka)
        settings->ssh_heartbeat_overtime = GetPrivateProfileInt("TTSSH", "HeartBeat", 60, fileName);

        // �p�X���[�h�F�����������J���F�����g���p�X���[�h����������������������������������
        // �\���B(2006.8.5 yutaka)
        settings->remember_password = GetPrivateProfileInt("TTSSH", "RememberPassword", 1, fileName);

        // �������F���_�C�A���O���T�|�[�g�������������\�b�h���`�F�b�N���A
        // ���������\�b�h���O���C�A�E�g���� (2007.9.24 maya)
        settings->CheckAuthListFirst = read_BOOL_option(fileName, "CheckAuthListFirst", FALSE);

        // 768bit ������ RSA ���������T�[�o�����������L�������� (2008.9.11 maya)
        settings->EnableRsaShortKeyServer = read_BOOL_option(fileName, "EnableRsaShortKeyServer", FALSE);

        // agent forward ���L�������� (2008.11.25 maya)
        settings->ForwardAgent = read_BOOL_option(fileName, "ForwardAgent", FALSE);

        clear_local_settings(pvar);
}

static void write_ssh_options(PTInstVar pvar, PCHAR fileName,
                                                          TS_SSH FAR * settings, BOOL copy_forward)
{
        char buf[1024];

        WritePrivateProfileString("TTSSH", "Enabled",
                                  settings->Enabled ? "1" : "0", fileName);

        _itoa(settings->CompressionLevel, buf, 10);
        WritePrivateProfileString("TTSSH", "Compression", buf, fileName);

        WritePrivateProfileString("TTSSH", "DefaultUserName",
                                  settings->DefaultUserName, fileName);

        if (copy_forward) {
                WritePrivateProfileString("TTSSH", "DefaultForwarding",
                                          settings->DefaultForwarding, fileName);
        }

        WritePrivateProfileString("TTSSH", "CipherOrder",
                                  settings->CipherOrder, fileName);

        WritePrivateProfileString("TTSSH", "KnownHostsFiles",
                                  settings->KnownHostsFiles, fileName);

        WritePrivateProfileString("TTSSH", "DefaultRhostsLocalUserName",
                                  settings->DefaultRhostsLocalUserName,
                                  fileName);

        WritePrivateProfileString("TTSSH", "DefaultRhostsHostPrivateKeyFile",
                                  settings->DefaultRhostsHostPrivateKeyFile,
                                  fileName);

        WritePrivateProfileString("TTSSH", "DefaultRSAPrivateKeyFile",
                                  settings->DefaultRSAPrivateKeyFile,
                                  fileName);

        _itoa(settings->DefaultAuthMethod, buf, 10);
        WritePrivateProfileString("TTSSH", "DefaultAuthMethod", buf, fileName);

        _itoa(settings->LogLevel, buf, 10);
        WritePrivateProfileString("TTSSH", "LogLevel", buf, fileName);

        _itoa(settings->WriteBufferSize, buf, 10);
        WritePrivateProfileString("TTSSH", "WriteBufferSize", buf, fileName);

        WritePrivateProfileString("TTSSH", "LocalForwardingIdentityCheck",
                                  settings->LocalForwardingIdentityCheck ? "1" : "0",
                                  fileName);

        // SSH protocol version (2004.10.11 yutaka)
        WritePrivateProfileString("TTSSH", "ProtocolVersion",
            settings->ssh_protocol_version==2 ? "2" : "1",
            fileName);

        // SSH heartbeat time(second) (2004.12.11 yutaka)
        _snprintf_s(buf, sizeof(buf), _TRUNCATE,
                    "%d", settings->ssh_heartbeat_overtime);
        WritePrivateProfileString("TTSSH", "HeartBeat", buf, fileName);

        // Remember password (2006.8.5 yutaka)
        WritePrivateProfileString("TTSSH", "RememberPassword",
            settings->remember_password ? "1" : "0",
            fileName);

        // �������F���_�C�A���O���T�|�[�g�������������\�b�h���`�F�b�N���A
        // ���������\�b�h���O���C�A�E�g���� (2007.9.24 maya)
        WritePrivateProfileString("TTSSH", "CheckAuthListFirst",
                                  settings->CheckAuthListFirst ? "1" : "0", fileName);

        // 768bit ������ RSA ���������T�[�o�����������L�������� (2008.9.11 maya)
        WritePrivateProfileString("TTSSH", "EnableRsaShortKeyServer",
                                  settings->EnableRsaShortKeyServer ? "1" : "0", fileName);

        // agent forward ���L�������� (2008.11.25 maya)
        WritePrivateProfileString("TTSSH", "ForwardAgent",
                                  settings->ForwardAgent ? "1" : "0", fileName);
}


/* find free port in all protocol family */
static unsigned short find_local_port(PTInstVar pvar)
{
        int tries;
#ifndef NO_INET6
        SOCKET connecter;
        struct addrinfo hints;
        struct addrinfo FAR *res;
        struct addrinfo FAR *res0;
        unsigned short port;
        char pname[NI_MAXHOST];
#endif                                                  /* NO_INET6 */

        if (pvar->session_settings.DefaultAuthMethod != SSH_AUTH_RHOSTS) {
                return 0;
        }

        /* The random numbers here are only used to try to get fresh
           ports across runs (dangling ports can cause bind errors
           if we're unlucky). They do not need to be (and are not)
           cryptographically strong.
         */
        srand((unsigned) GetTickCount());

#ifndef NO_INET6
        for (tries = 20; tries > 0; tries--) {
                memset(&hints, 0, sizeof(hints));
                hints.ai_family = pvar->ts->ProtocolFamily;
                hints.ai_flags = AI_PASSIVE;
                hints.ai_socktype = SOCK_STREAM;
                port = (unsigned) rand() % 512 + 512;
                _snprintf_s(pname, sizeof(pname), _TRUNCATE, "%d", (int) port);
                if (getaddrinfo(NULL, pname, &hints, &res0)) {
                        return 0;
                        /* NOT REACHED */
                }

                for (res = res0; res; res = res->ai_next) {
                        if (res->ai_family == AF_INET || res->ai_family == AF_INET6)
                                continue;

                        connecter =
                                socket(res->ai_family, res->ai_socktype, res->ai_protocol);
                        if (connecter == INVALID_SOCKET) {
                                freeaddrinfo(res0);
                                return 0;
                        }

                        if (bind(connecter, res->ai_addr, res->ai_addrlen) !=
                            SOCKET_ERROR) {
                                return port;
                                freeaddrinfo(res0);
                                closesocket(connecter);
                        } else if (WSAGetLastError() != WSAEADDRINUSE) {
                                closesocket(connecter);
                                freeaddrinfo(res0);
                                return 0;
                        }

                        closesocket(connecter);
                }
                freeaddrinfo(res0);
        }

        return 0;
#else
        for (tries = 20; tries > 0; tries--) {
                SOCKET connecter = socket(AF_INET, SOCK_STREAM, 0);
                struct sockaddr_in connecter_addr;

                connecter_addr.sin_family = AF_INET;
                connecter_addr.sin_port = (unsigned) rand() % 512 + 512;
                connecter_addr.sin_addr.s_addr = htonl(INADDR_ANY);

                if (connecter == INVALID_SOCKET) {
                        return 0;
                }

                if (bind
                    (connecter, (struct sockaddr FAR *) &connecter_addr,
                     sizeof(connecter_addr)) != SOCKET_ERROR) {
                    closesocket(connecter);
                        return connecter_addr.sin_port;
                } else if (WSAGetLastError() != WSAEADDRINUSE) {
                        closesocket(connecter);
                        return 0;
                }

                closesocket(connecter);
        }

        return 0;
#endif                                                  /* NO_INET6 */
}

static int PASCAL FAR TTXconnect(SOCKET s,
                                 const struct sockaddr FAR * name,
                                 int namelen)
{
#ifndef NO_INET6
        if (pvar->socket == INVALID_SOCKET) {
                struct sockaddr_storage ss;
                int len;

                pvar->socket = s;

                memset(&ss, 0, sizeof(ss));
                switch (pvar->ts->ProtocolFamily) {
                case AF_INET:
                        len = sizeof(struct sockaddr_in);
                        ((struct sockaddr_in FAR *) &ss)->sin_family = AF_INET;
                        ((struct sockaddr_in FAR *) &ss)->sin_addr.s_addr = INADDR_ANY;
                        ((struct sockaddr_in FAR *) &ss)->sin_port =
                                htons(find_local_port(pvar));
                        break;
                case AF_INET6:
                        len = sizeof(struct sockaddr_in6);
                        ((struct sockaddr_in6 FAR *) &ss)->sin6_family = AF_INET6;
#if 0                                                   /* symbol "in6addr_any" is not included in wsock32.lib */
                        /* if wsock32.lib will be linked, we can't refer "in6addr_any" */
                        ((struct sockaddr_in6 FAR *) &ss)->sin6_addr = in6addr_any;
#else
                        memset(&((struct sockaddr_in6 FAR *) &ss)->sin6_addr, 0,
                               sizeof(struct in_addr6));
#endif                                                  /* 0 */
                        ((struct sockaddr_in6 FAR *) &ss)->sin6_port =
                                htons(find_local_port(pvar));
                        break;
                default:
                        /* NOT REACHED */
                        break;
                }

                bind(s, (struct sockaddr FAR *) &ss, len);
        }
#else
        if (pvar->socket == INVALID_SOCKET) {
                struct sockaddr_in addr;

                pvar->socket = s;

                addr.sin_family = AF_INET;
                addr.sin_port = htons(find_local_port(pvar));
                addr.sin_addr.s_addr = INADDR_ANY;
                memset(addr.sin_zero, 0, sizeof(addr.sin_zero));

                bind(s, (struct sockaddr FAR *) &addr, sizeof(addr));
        }
#endif                                                  /* NO_INET6 */

        return (pvar->Pconnect) (s, name, namelen);
}

static int PASCAL FAR TTXWSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg,
                                        long lEvent)
{
        if (s == pvar->socket) {
                pvar->notification_events = lEvent;
                pvar->notification_msg = wMsg;

                if (pvar->NotificationWindow == NULL) {
                        pvar->NotificationWindow = hWnd;
                        AUTH_advance_to_next_cred(pvar);
                }
        }

        return (pvar->PWSAAsyncSelect) (s, hWnd, wMsg, lEvent);
}

static int PASCAL FAR TTXrecv(SOCKET s, char FAR * buf, int len, int flags)
{
        if (s == pvar->socket) {
                int ret;

                ssh_heartbeat_lock();
                ret = PKT_recv(pvar, buf, len);
                ssh_heartbeat_unlock();
                return (ret);

        } else {
                return (pvar->Precv) (s, buf, len, flags);
        }
}

static int PASCAL FAR TTXsend(SOCKET s, char const FAR * buf, int len,
                              int flags)
{
        if (s == pvar->socket) {
                ssh_heartbeat_lock();
                SSH_send(pvar, buf, len);
                ssh_heartbeat_unlock();
                return len;
        } else {
                return (pvar->Psend) (s, buf, len, flags);
        }
}

void notify_established_secure_connection(PTInstVar pvar)
{
        int fuLoad = LR_DEFAULTCOLOR;

        if (is_NT4()) {
                fuLoad = LR_VGACOLOR;
        }

        // LoadIcon �������� LoadImage ���g�����������A
        // 16x16 ���A�C�R���������I�������������������� (2006.8.9 maya)
        if (SecureLargeIcon == NULL) {
                SecureLargeIcon = LoadImage(hInst, MAKEINTRESOURCE(IDI_SECURETT),
                                            IMAGE_ICON, 0, 0, fuLoad);
        }
        if (SecureSmallIcon == NULL) {
                SecureSmallIcon = LoadImage(hInst, MAKEINTRESOURCE(IDI_SECURETT),
                                            IMAGE_ICON, 16, 16, fuLoad);
        }

        if (SecureLargeIcon != NULL && SecureSmallIcon != NULL) {
                // �������A�C�R���� WNDCLASS ���Z�b�g�����������������o���������� (2006.8.10 maya)
                pvar->OldLargeIcon =
                        (HICON) GetClassLong(pvar->NotificationWindow, GCL_HICON);
                pvar->OldSmallIcon =
                        (HICON) SendMessage(pvar->NotificationWindow, WM_GETICON,
                                            ICON_SMALL, 0);

                PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_BIG,
                            (LPARAM) SecureLargeIcon);
                PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_SMALL,
                            (LPARAM) SecureSmallIcon);
        }

        notify_verbose_message(pvar, "Entering secure mode",
                               LOG_LEVEL_VERBOSE);
}

void notify_closed_connection(PTInstVar pvar)
{
        SSH_notify_disconnecting(pvar, NULL);
        AUTH_notify_disconnecting(pvar);
        HOSTS_notify_disconnecting(pvar);

        PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
                    pvar->socket, MAKELPARAM(FD_CLOSE, 0));

}

static void add_err_msg(PTInstVar pvar, char FAR * msg)
{
        if (pvar->err_msg != NULL) {
                int buf_len = strlen(pvar->err_msg) + 3 + strlen(msg);
                char FAR *buf = (char FAR *) malloc(buf_len);

                strncpy_s(buf, buf_len, pvar->err_msg, _TRUNCATE);
                strncat_s(buf, buf_len, "\n\n", _TRUNCATE);
                strncat_s(buf, buf_len, msg, _TRUNCATE);
                free(pvar->err_msg);
                pvar->err_msg = buf;
        } else {
                pvar->err_msg = _strdup(msg);
        }
}

void notify_nonfatal_error(PTInstVar pvar, char FAR * msg)
{
        if (!pvar->showing_err) {
                // �������������������m���E�B���h�E�����������A�f�X�N�g�b�v���I�[�i�[������
                // ���b�Z�[�W�{�b�N�X���o���������B(2006.6.11 yutaka)
                if (pvar->NotificationWindow == NULL) {
                        UTIL_get_lang_msg("MSG_ERROR_NONFAITAL", pvar,
                                          "Tera Term: not fatal error");
                        MessageBox(NULL, msg, pvar->ts->UIMsg, MB_OK|MB_ICONINFORMATION);
                        msg[0] = '\0';

                } else {
                        PostMessage(pvar->NotificationWindow, WM_COMMAND,
                                    ID_SSHASYNCMESSAGEBOX, 0);
                }
        }
        if (msg[0] != 0) {
                notify_verbose_message(pvar, msg, LOG_LEVEL_ERROR);
                add_err_msg(pvar, msg);
        }
}

void notify_fatal_error(PTInstVar pvar, char FAR * msg)
{
        if (msg[0] != 0) {
                notify_verbose_message(pvar, msg, LOG_LEVEL_FATAL);
                add_err_msg(pvar, msg);
        }

        if (!pvar->fatal_error) {
                pvar->fatal_error = TRUE;

                SSH_notify_disconnecting(pvar, msg);
                AUTH_notify_disconnecting(pvar);
                HOSTS_notify_disconnecting(pvar);

                PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
                            pvar->socket, MAKELPARAM(FD_CLOSE,
                                                     (pvar->PWSAGetLastError) ()));
        }
}

void notify_verbose_message(PTInstVar pvar, char FAR * msg, int level)
{
        if (level <= pvar->session_settings.LogLevel) {
                char buf[1024];
                int file;

                get_teraterm_dir_relative_name(buf, NUM_ELEM(buf), "TTSSH.LOG");
                file = _open(buf, _O_RDWR | _O_APPEND | _O_CREAT | _O_TEXT,
                             _S_IREAD | _S_IWRITE);

                if (file >= 0) {
                        time_t now = time(NULL);
                        char tmp[26];
                        DWORD processid;
                        strcpy_s(tmp, sizeof(tmp), ctime(&now));
                        tmp[strlen(tmp)-1]= 0; // delete "\n"
                        _write(file, tmp, strlen(tmp));
                        GetWindowThreadProcessId(pvar->cv->HWin, &processid);
                        _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, " [%lu] ",processid);
                        _write(file, tmp, strlen(tmp));
                        _write(file, msg, strlen(msg));
                        _write(file, "\n", 1);
                        _close(file);
                }
        }
}

static void PASCAL FAR TTXOpenTCP(TTXSockHooks FAR * hooks)
{
        if (pvar->settings.Enabled) {
                // TCPLocalEcho/TCPCRSend ������������ (maya 2007.4.25)
                pvar->ts->DisableTCPEchoCR = TRUE;

                pvar->session_settings = pvar->settings;

                notify_verbose_message(pvar, "---------------------------------------------------------------------", LOG_LEVEL_VERBOSE);
                notify_verbose_message(pvar, "Initiating SSH session", LOG_LEVEL_VERBOSE);

                FWDUI_load_settings(pvar);

                pvar->cv->TelAutoDetect = FALSE;
                /* This next line should not be needed because Tera Term's
                   CommLib should find ts->Telnet == 0 ... but we'll do this
                   just to be on the safe side. */
                pvar->cv->TelFlag = FALSE;

                pvar->Precv = *hooks->Precv;
                pvar->Psend = *hooks->Psend;
                pvar->PWSAAsyncSelect = *hooks->PWSAAsyncSelect;
                pvar->Pconnect = *hooks->Pconnect;
                pvar->PWSAGetLastError = *hooks->PWSAGetLastError;

                *hooks->Precv = TTXrecv;
                *hooks->Psend = TTXsend;
                *hooks->PWSAAsyncSelect = TTXWSAAsyncSelect;
                *hooks->Pconnect = TTXconnect;

                SSH_open(pvar);
                HOSTS_open(pvar);
                FWDUI_open(pvar);

                // ������ myproposal �����f���������A�������O�����������B (2006.6.26 maya)
                SSH2_update_cipher_myproposal(pvar);
                SSH2_update_compression_myproposal(pvar);
        }
}

static void PASCAL FAR TTXCloseTCP(TTXSockHooks FAR * hooks)
{
        if (pvar->session_settings.Enabled) {
                pvar->socket = INVALID_SOCKET;

                notify_verbose_message(pvar, "Terminating SSH session...",
                                       LOG_LEVEL_VERBOSE);

                *hooks->Precv = pvar->Precv;
                *hooks->Psend = pvar->Psend;
                *hooks->PWSAAsyncSelect = pvar->PWSAAsyncSelect;
                *hooks->Pconnect = pvar->Pconnect;
        }

        uninit_TTSSH(pvar);
        init_TTSSH(pvar);
}

static void enable_dlg_items(HWND dlg, int from, int to, BOOL enabled)
{
        for (; from <= to; from++) {
                EnableWindow(GetDlgItem(dlg, from), enabled);
        }
}

// C-p/C-n/C-b/C-f/C-a/C-e ���T�|�[�g (2007.9.5 maya)
// C-d/C-k ���T�|�[�g (2007.10.3 yutaka)
// �h���b�v�_�E���������G�f�B�b�g�R���g���[����
// �T�u�N���X�������������E�C���h�E�v���V�[�W��
WNDPROC OrigHostnameEditProc; // Original window procedure
LRESULT CALLBACK HostnameEditProc(HWND dlg, UINT msg,
                                         WPARAM wParam, LPARAM lParam)
{
        HWND parent;
        int  max, select, len;
        char *str, *orgstr;

        switch (msg) {
                // �L�[�����������������m����
                case WM_KEYDOWN:
                        if (GetKeyState(VK_CONTROL) < 0) {
                                switch (wParam) {
                                        case 0x50: // Ctrl+p ... up
                                                parent = GetParent(dlg);
                                                select = SendMessage(parent, CB_GETCURSEL, 0, 0);
                                                if (select > 0) {
                                                        PostMessage(parent, CB_SETCURSEL, select - 1, 0);
                                                }
                                                return 0;
                                        case 0x4e: // Ctrl+n ... down
                                                parent = GetParent(dlg);
                                                max = SendMessage(parent, CB_GETCOUNT, 0, 0);
                                                select = SendMessage(parent, CB_GETCURSEL, 0, 0);
                                                if (select < max - 1) {
                                                        PostMessage(parent, CB_SETCURSEL, select + 1, 0);
                                                }
                                                return 0;
                                        case 0x42: // Ctrl+b ... left
                                                SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
                                                PostMessage(dlg, EM_SETSEL, select-1, select-1);
                                                return 0;
                                        case 0x46: // Ctrl+f ... right
                                                SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
                                                max = GetWindowTextLength(dlg) ;
                                                PostMessage(dlg, EM_SETSEL, select+1, select+1);
                                                return 0;
                                        case 0x41: // Ctrl+a ... home
                                                PostMessage(dlg, EM_SETSEL, 0, 0);
                                                return 0;
                                        case 0x45: // Ctrl+e ... end
                                                max = GetWindowTextLength(dlg) ;
                                                PostMessage(dlg, EM_SETSEL, max, max);
                                                return 0;

                                        case 0x44: // Ctrl+d
                                        case 0x4b: // Ctrl+k
                                        case 0x55: // Ctrl+u
                                                SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
                                                max = GetWindowTextLength(dlg);
                                                max++; // '\0'
                                                orgstr = str = malloc(max);
                                                if (str != NULL) {
                                                        len = GetWindowText(dlg, str, max);
                                                        if (select >= 0 && select < len) {
                                                                if (wParam == 0x44) { // �J�[�\���z����������������������
                                                                        memmove(&str[select], &str[select + 1], len - select - 1);
                                                                        str[len - 1] = '\0';

                                                                } else if (wParam == 0x4b) { // �J�[�\�������s��������������
                                                                        str[select] = '\0';

                                                                }
                                                        }

                                                        if (wParam == 0x55) { // �J�[�\����������������������
                                                                if (select >= len) {
                                                                        str[0] = '\0';
                                                                } else {
                                                                        str = &str[select];
                                                                }
                                                                select = 0;
                                                        }

                                                        SetWindowText(dlg, str);
                                                        SendMessage(dlg, EM_SETSEL, select, select);
                                                        free(orgstr);
                                                        return 0;
                                                }
                                                break;
                                }
                        }
                        break;

                // �����L�[��������������������������������������������
                case WM_CHAR:
                        switch (wParam) {
                                case 0x01:
                                case 0x02:
                                case 0x04:
                                case 0x05:
                                case 0x06:
                                case 0x0b:
                                case 0x0e:
                                case 0x10:
                                case 0x15:
                                        return 0;
                        }
        }

        return CallWindowProc(OrigHostnameEditProc, dlg, msg, wParam, lParam);
}

static BOOL CALLBACK TTXHostDlg(HWND dlg, UINT msg, WPARAM wParam,
                                LPARAM lParam)
{
        static char *ssh_version[] = {"SSH1", "SSH2", NULL};
        PGetHNRec GetHNRec;
        char EntName[128];
        char TempHost[HostNameMaxLength + 1];
        WORD i, j, w;
        WORD ComPortTable[MAXCOMPORT];
        static char *ComPortDesc[MAXCOMPORT];
        int comports;
        BOOL Ok;
        LOGFONT logfont;
        HFONT font;
        char uimsg[MAX_UIMSG];
        static HWND hwndHostname     = NULL; // HOSTNAME dropdown
        static HWND hwndHostnameEdit = NULL; // Edit control on HOSTNAME dropdown

        switch (msg) {
        case WM_INITDIALOG:
                GetHNRec = (PGetHNRec) lParam;
                SetWindowLong(dlg, DWL_USER, lParam);

                GetWindowText(dlg, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("DLG_HOST_TITLE", pvar, uimsg);
                SetWindowText(dlg, pvar->ts->UIMsg);
                GetDlgItemText(dlg, IDC_HOSTNAMELABEL, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("DLG_HOST_TCPIPHOST", pvar, uimsg);
                SetDlgItemText(dlg, IDC_HOSTNAMELABEL, pvar->ts->UIMsg);
                GetDlgItemText(dlg, IDC_HISTORY, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("DLG_HOST_TCPIPHISTORY", pvar, uimsg);
                SetDlgItemText(dlg, IDC_HISTORY, pvar->ts->UIMsg);
                GetDlgItemText(dlg, IDC_SERVICELABEL, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("DLG_HOST_TCPIPSERVICE", pvar, uimsg);
                SetDlgItemText(dlg, IDC_SERVICELABEL, pvar->ts->UIMsg);
                GetDlgItemText(dlg, IDC_HOSTOTHER, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("DLG_HOST_TCPIPOTHER", pvar, uimsg);
                SetDlgItemText(dlg, IDC_HOSTOTHER, pvar->ts->UIMsg);
                GetDlgItemText(dlg, IDC_HOSTTCPPORTLABEL, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("DLG_HOST_TCPIPPORT", pvar, uimsg);
                SetDlgItemText(dlg, IDC_HOSTTCPPORTLABEL, pvar->ts->UIMsg);
                GetDlgItemText(dlg, IDC_SSH_VERSION_LABEL, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("DLG_HOST_TCPIPSSHVERSION", pvar, uimsg);
                SetDlgItemText(dlg, IDC_SSH_VERSION_LABEL, pvar->ts->UIMsg);
                GetDlgItemText(dlg, IDC_HOSTTCPPROTOCOLLABEL, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("DLG_HOST_TCPIPPROTOCOL", pvar, uimsg);
                SetDlgItemText(dlg, IDC_HOSTTCPPROTOCOLLABEL, pvar->ts->UIMsg);
                GetDlgItemText(dlg, IDC_HOSTSERIAL, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("DLG_HOST_SERIAL", pvar, uimsg);
                SetDlgItemText(dlg, IDC_HOSTSERIAL, pvar->ts->UIMsg);
                GetDlgItemText(dlg, IDC_HOSTCOMLABEL, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("DLG_HOST_SERIALPORT", pvar, uimsg);
                SetDlgItemText(dlg, IDC_HOSTCOMLABEL, pvar->ts->UIMsg);
                GetDlgItemText(dlg, IDC_HOSTHELP, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("DLG_HOST_HELP", pvar, uimsg);
                SetDlgItemText(dlg, IDC_HOSTHELP, pvar->ts->UIMsg);
                GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
                SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
                GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
                UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
                SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);

                // �z�X�g�q�X�g�����`�F�b�N�{�b�N�X������ (2005.10.21 yutaka)
                if (pvar->ts->HistoryList > 0) {
                        SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_SETCHECK, BST_CHECKED, 0);
                } else {
                        SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_SETCHECK, BST_UNCHECKED, 0);
                }

                if (GetHNRec->PortType == IdFile)
                        GetHNRec->PortType = IdTCPIP;

                strncpy_s(EntName, sizeof(EntName), "Host", _TRUNCATE);

                i = 1;
                do {
                        _snprintf_s(&EntName[4], sizeof(EntName)-4, _TRUNCATE, "%d", i);
                        GetPrivateProfileString("Hosts", EntName, "",
                                                TempHost, sizeof(TempHost),
                                                GetHNRec->SetupFN);
                        if (strlen(TempHost) > 0)
                                SendDlgItemMessage(dlg, IDC_HOSTNAME, CB_ADDSTRING,
                                                   0, (LPARAM) TempHost);
                        i++;
                } while ((i <= MAXHOSTLIST) && (strlen(TempHost) > 0));

                SendDlgItemMessage(dlg, IDC_HOSTNAME, EM_LIMITTEXT,
                                   HostNameMaxLength - 1, 0);

                SendDlgItemMessage(dlg, IDC_HOSTNAME, CB_SETCURSEL, 0, 0);

                // C-n/C-p ���������T�u�N���X�� (2007.9.4 maya)
                hwndHostname = GetDlgItem(dlg, IDC_HOSTNAME);
                hwndHostnameEdit = GetWindow(hwndHostname, GW_CHILD);
                OrigHostnameEditProc = (WNDPROC)GetWindowLong(hwndHostnameEdit, GWL_WNDPROC);
                SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)HostnameEditProc);

                CheckRadioButton(dlg, IDC_HOSTTELNET, IDC_HOSTOTHER,
                                 pvar->settings.Enabled ? IDC_HOSTSSH : GetHNRec->
                                 Telnet ? IDC_HOSTTELNET : IDC_HOSTOTHER);
                SendDlgItemMessage(dlg, IDC_HOSTTCPPORT, EM_LIMITTEXT, 5, 0);
                SetDlgItemInt(dlg, IDC_HOSTTCPPORT, GetHNRec->TCPPort, FALSE);
#ifndef NO_INET6
                for (i = 0; ProtocolFamilyList[i]; ++i) {
                        SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, CB_ADDSTRING,
                                           0, (LPARAM) ProtocolFamilyList[i]);
                }
                SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, EM_LIMITTEXT,
                                   ProtocolFamilyMaxLength - 1, 0);
                SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, CB_SETCURSEL, 0, 0);
#endif                                                  /* NO_INET6 */

                /////// SSH version
                for (i = 0; ssh_version[i]; ++i) {
                        SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_ADDSTRING,
                                           0, (LPARAM) ssh_version[i]);
                }
                SendDlgItemMessage(dlg, IDC_SSH_VERSION, EM_LIMITTEXT,
                                   NUM_ELEM(ssh_version) - 1, 0);

                if (pvar->settings.ssh_protocol_version == 1) {
                        SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_SETCURSEL, 0, 0); // SSH1
                } else {
                        SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_SETCURSEL, 1, 0); // SSH2
                }

                if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
                        enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE); // enabled
                } else {
                        enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
                }
                /////// SSH version


                j = 0;
                w = 1;
                if ((comports=DetectComPorts(ComPortTable, GetHNRec->MaxComPort, ComPortDesc)) >= 0) {
                        for (i=0; i<comports; i++) {
                                // MaxComPort ���z�����|�[�g���\��������
                                if (ComPortTable[i] > GetHNRec->MaxComPort) {
                                        continue;
                                }

                                // �g�p�����|�[�g���\��������
                                if (CheckCOMFlag(ComPortTable[i]) == 1) {
                                        continue;
                                }

                                _snprintf_s(EntName, sizeof(EntName), _TRUNCATE, "COM%d", ComPortTable[i]);
                                if (ComPortDesc[i] != NULL) {
                                        strncat_s(EntName, sizeof(EntName), ": ", _TRUNCATE);
                                        strncat_s(EntName, sizeof(EntName), ComPortDesc[i], _TRUNCATE);
                                }
                                SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_ADDSTRING,
                                                   0, (LPARAM)EntName);
                                j++;
                                if (GetHNRec->ComPort == ComPortTable[i])
                                        w = j;
                        }

                } else {
                        for (i = 1; i <= GetHNRec->MaxComPort; i++) {
                                // �g�p�����|�[�g���\��������
                                if (CheckCOMFlag(i) == 1) {
                                        continue;
                                }

                                _snprintf_s(EntName, sizeof(EntName), _TRUNCATE, "COM%d", i);
                                SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_ADDSTRING,
                                                   0, (LPARAM) EntName);
                                j++;
                                if (GetHNRec->ComPort == i)
                                        w = j;
                        }
                }

                if (j > 0)
                        SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_SETCURSEL, w - 1, 0);
                else {                                  /* All com ports are already used */
                        GetHNRec->PortType = IdTCPIP;
                        enable_dlg_items(dlg, IDC_HOSTSERIAL, IDC_HOSTSERIAL, FALSE);
                }

                CheckRadioButton(dlg, IDC_HOSTTCPIP, IDC_HOSTSERIAL,
                                 IDC_HOSTTCPIP + GetHNRec->PortType - 1);

                if (GetHNRec->PortType == IdTCPIP) {
                        enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, FALSE);

                        enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE);
                        enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, TRUE);

                        enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, TRUE); // enabled
                }
#ifndef NO_INET6
                else {
                        enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
                                         FALSE);
                        enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
                                         IDC_HOSTTCPPROTOCOL, FALSE);

                        enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
                        enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, FALSE); // disabled (2004.11.23 yutaka)

                        enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, FALSE); // disabled
                }
#else
                else
                        enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
                                                         FALSE);
#endif                                                  /* NO_INET6 */

                // Host dialog���t�H�[�J�X�������� (2004.10.2 yutaka)
                if (GetHNRec->PortType == IdTCPIP) {
                        HWND hwnd = GetDlgItem(dlg, IDC_HOSTNAME);
                        SetFocus(hwnd);
                } else {
                        HWND hwnd = GetDlgItem(dlg, IDC_HOSTCOM);
                        SetFocus(hwnd);
                }

                font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
                GetObject(font, sizeof(LOGFONT), &logfont);
                if (UTIL_get_lang_font("DLG_SYSTEM_FONT", dlg, &logfont, &DlgHostFont, pvar)) {
                        SendDlgItemMessage(dlg, IDC_HOSTTCPIP, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_HOSTNAMELABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_HOSTNAME, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_HISTORY, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_SERVICELABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_HOSTTELNET, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_HOSTSSH, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_HOSTOTHER, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_HOSTTCPPORTLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_HOSTTCPPORT, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_SSH_VERSION_LABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_SSH_VERSION, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOLLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_HOSTSERIAL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_HOSTCOMLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_HOSTCOM, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_HOSTHELP, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
                }
                else {
                        DlgHostFont = NULL;
                }

                // SetFocus()���t�H�[�J�X���������������AFALSE�������K�v�������B
                // TRUE���������ATABSTOP�������������������R���g���[�����I�������B
                // (2004.11.23 yutaka)
                return FALSE;
                //return TRUE;

        case WM_COMMAND:
                switch (LOWORD(wParam)) {
                case IDOK:
                        GetHNRec = (PGetHNRec) GetWindowLong(dlg, DWL_USER);
                        if (GetHNRec != NULL) {
                                if (IsDlgButtonChecked(dlg, IDC_HOSTTCPIP)) {
#ifndef NO_INET6
                                        char afstr[BUFSIZ];
#endif                                                  /* NO_INET6 */
                                        i = GetDlgItemInt(dlg, IDC_HOSTTCPPORT, &Ok, FALSE);
                                        if (Ok) {
                                                GetHNRec->TCPPort = i;
                                        } else {
                                                UTIL_get_lang_msg("MSG_TCPPORT_NAN_ERROR", pvar,
                                                                  "The TCP port must be a number.");
                                                MessageBox(dlg, pvar->ts->UIMsg,
                                                           "Tera Term", MB_OK | MB_ICONEXCLAMATION);
                                                return TRUE;
                                        }
#ifndef NO_INET6
#define getaf(str) \
((strcmp((str), "IPv6") == 0) ? AF_INET6 : \
 ((strcmp((str), "IPv4") == 0) ? AF_INET : AF_UNSPEC))
                                        memset(afstr, 0, sizeof(afstr));
                                        GetDlgItemText(dlg, IDC_HOSTTCPPROTOCOL, afstr,
                                                       sizeof(afstr));
                                        GetHNRec->ProtocolFamily = getaf(afstr);
#endif                                                  /* NO_INET6 */
                                        GetHNRec->PortType = IdTCPIP;
                                        GetDlgItemText(dlg, IDC_HOSTNAME, GetHNRec->HostName,
                                                       HostNameMaxLength);
                                        GetHNRec->Telnet = FALSE;
                                        pvar->hostdlg_activated = TRUE;
                                        pvar->hostdlg_Enabled = FALSE;
                                        if (IsDlgButtonChecked(dlg, IDC_HOSTTELNET)) {
                                                GetHNRec->Telnet = TRUE;
                                        } else if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
                                                pvar->hostdlg_Enabled = TRUE;

                                                // check SSH protocol version
                                                memset(afstr, 0, sizeof(afstr));
                                                GetDlgItemText(dlg, IDC_SSH_VERSION, afstr, sizeof(afstr));
                                                if (_stricmp(afstr, "SSH1") == 0) {
                                                        pvar->settings.ssh_protocol_version = 1;
                                                } else {
                                                        pvar->settings.ssh_protocol_version = 2;
                                                }
                                        }

                                        // host history check button
                                        if (SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_GETCHECK, 0, 0) == BST_CHECKED) {
                                                pvar->ts->HistoryList = 1;
                                        } else {
                                                pvar->ts->HistoryList = 0;
                                        }

                                } else {
                                        GetHNRec->PortType = IdSerial;
                                        GetHNRec->HostName[0] = 0;
                                        memset(EntName, 0, sizeof(EntName));
                                        GetDlgItemText(dlg, IDC_HOSTCOM, EntName,
                                                       sizeof(EntName) - 1);
                                        if (strncmp(EntName, "COM", 3) == 0 && EntName[3] != '\0') {
#if 0
                                                GetHNRec->ComPort = (BYTE) (EntName[3]) - 0x30;
                                                if (strlen(EntName) > 4)
                                                        GetHNRec->ComPort =
                                                                GetHNRec->ComPort * 10 + (BYTE) (EntName[4]) -
                                                                0x30;
#else
                                                GetHNRec->ComPort = atoi(&EntName[3]);
#endif
                                                if (GetHNRec->ComPort > GetHNRec->MaxComPort)
                                                        GetHNRec->ComPort = 1;
                                        } else {
                                                GetHNRec->ComPort = 1;
                                        }
                                }
                        }
                        SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)OrigHostnameEditProc);
                        EndDialog(dlg, 1);

                        if (DlgHostFont != NULL) {
                                DeleteObject(DlgHostFont);
                        }

                        return TRUE;

                case IDCANCEL:
                        SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)OrigHostnameEditProc);
                        EndDialog(dlg, 0);

                        if (DlgHostFont != NULL) {
                                DeleteObject(DlgHostFont);
                        }

                        return TRUE;

                case IDC_HOSTTCPIP:
                        enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
                                         TRUE);
#ifndef NO_INET6
                        enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
                                         IDC_HOSTTCPPROTOCOL, TRUE);
#endif                                                  /* NO_INET6 */
                        enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, FALSE);

                        enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, TRUE); // disabled (2004.11.23 yutaka)
                        if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
                                enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE);
                        } else {
                                enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
                        }

                        enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, TRUE); // disabled

                        return TRUE;

                case IDC_HOSTSERIAL:
                        enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, TRUE);
                        enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
                                         FALSE);
#ifndef NO_INET6
                        enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
                                         IDC_HOSTTCPPROTOCOL, FALSE);
#endif                                                  /* NO_INET6 */
                        enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
                        enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, FALSE); // disabled (2004.11.23 yutaka)

                        enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, FALSE); // disabled

                        return TRUE;

                case IDC_HOSTSSH:
                        enable_dlg_items(dlg, IDC_SSH_VERSION,
                                         IDC_SSH_VERSION, TRUE);
                        goto hostssh_enabled;

                case IDC_HOSTTELNET:
                case IDC_HOSTOTHER:
                        enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
hostssh_enabled:

                        GetHNRec = (PGetHNRec) GetWindowLong(dlg, DWL_USER);

                        if (IsDlgButtonChecked(dlg, IDC_HOSTTELNET)) {
                                if (GetHNRec != NULL)
                                        SetDlgItemInt(dlg, IDC_HOSTTCPPORT, GetHNRec->TelPort,
                                                      FALSE);
                        } else if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
                                SetDlgItemInt(dlg, IDC_HOSTTCPPORT, 22, FALSE);
                        }
                        return TRUE;

                case IDC_HOSTCOM:
                        if(HIWORD(wParam) == CBN_DROPDOWN) {
                                HWND hostcom = GetDlgItem(dlg, IDC_HOSTCOM);
                                int count = SendMessage(hostcom, CB_GETCOUNT, 0, 0);
                                int i, len, max_len = 0;
                                char *lbl;
                                HDC TmpDC = GetDC(hostcom);
                                SIZE s;
                                for (i=0; i<count; i++) {
                                        len = SendMessage(hostcom, CB_GETLBTEXTLEN, i, 0);
                                        lbl = (char *)calloc(len+1, sizeof(char));
                                        SendMessage(hostcom, CB_GETLBTEXT, i, (LPARAM)lbl);
                                        GetTextExtentPoint32(TmpDC, lbl, len, &s);
                                        if (s.cx > max_len)
                                                max_len = s.cx;
                                        free(lbl);
                                }
                                SendMessage(hostcom, CB_SETDROPPEDWIDTH,
                                                        max_len + GetSystemMetrics(SM_CXVSCROLL), 0);
                        }
                        break;

                case IDC_HOSTHELP:
                        PostMessage(GetParent(dlg), WM_USER_DLGHELP2, 0, 0);
                }
        }
        return FALSE;
}

static BOOL FAR PASCAL TTXGetHostName(HWND parent, PGetHNRec rec)
{
        return (BOOL) DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_HOSTDLG),
                                     parent, TTXHostDlg, (LONG) rec);
}

static void PASCAL FAR TTXGetUIHooks(TTXUIHooks FAR * hooks)
{
        *hooks->GetHostName = TTXGetHostName;
}

static void FAR PASCAL TTXReadINIFile(PCHAR fileName, PTTSet ts)
{
        (pvar->ReadIniFile) (fileName, ts);
        read_ssh_options(pvar, fileName);
        pvar->settings = *pvar->ts_SSH;
        notify_verbose_message(pvar, "Reading INI file", LOG_LEVEL_VERBOSE);
        FWDUI_load_settings(pvar);
}

static void FAR PASCAL TTXWriteINIFile(PCHAR fileName, PTTSet ts)
{
        (pvar->WriteIniFile) (fileName, ts);
        *pvar->ts_SSH = pvar->settings;
        clear_local_settings(pvar);
        notify_verbose_message(pvar, "Writing INI file", LOG_LEVEL_VERBOSE);
        write_ssh_options(pvar, fileName, pvar->ts_SSH, TRUE);
}

static void read_ssh_options_from_user_file(PTInstVar pvar,
                                            char FAR * user_file_name)
{
        if (user_file_name[0] == '.') {
                read_ssh_options(pvar, user_file_name);
        } else {
                char buf[1024];

                get_teraterm_dir_relative_name(buf, sizeof(buf), user_file_name);
                read_ssh_options(pvar, buf);
        }

        pvar->settings = *pvar->ts_SSH;
        FWDUI_load_settings(pvar);
}


// @���u�����N���u�������B (2005.1.26 yutaka)
static void replace_to_blank(char *src, char *dst, int dst_len)
{
        int len, i;

        len = strlen(src);
        if (dst_len < len) // buffer overflow check
                return;

        for (i = 0 ; i < len ; i++) {
                if (src[i] == '@') { // @ ���o��������
                        if (i < len - 1 && src[i + 1] == '@') { // �������� @ �����A�b�g�}�[�N���F������
                                *dst++ = '@';
                                i++;
                        } else {
                                *dst++ = ' '; // �������u��������
                        }
                } else {
                        *dst++ = src[i];
                }
        }
        *dst = '\0';
}

// Percent-encode������������src���f�R�[�h����dst���R�s�[�����B
// dstlen��dst���T�C�Y�B�����������������������A�����������������������B
static void percent_decode(char *dst, int dstlen, char *src) {
        if (src == NULL || dst == NULL || dstlen < 1) {
                return;
        }

        while (*src != 0 && dstlen > 1) {
                if (*src == '%' && isxdigit(*(src+1)) && isxdigit(*(src+2))) {
                        src++; *dst  = (isalpha(*src) ? (*src|0x20) - 'a' + 10 : *src - '0') << 4;
                        src++; *dst |= (isalpha(*src) ? (*src|0x20) - 'a' + 10 : *src - '0');
                        src++; dst++;
                }
                else {
                        *dst++ = *src++;
                }
                dstlen--;
        }
        *dst = 0;
        return;
}

/* returns 1 if the option text must be deleted */
static int parse_option(PTInstVar pvar, char FAR * option)
{
        if ((option[0] == '-' || option[0] == '/')) {
                if (MATCH_STR(option + 1, "ssh") == 0) {
                        if (option[4] == 0) {
                                pvar->settings.Enabled = 1;
                        } else if (MATCH_STR(option + 4, "-L") == 0 ||
                                   MATCH_STR(option + 4, "-R") == 0 ||
                                   _stricmp(option + 4, "-X") == 0) {
                                if (pvar->settings.DefaultForwarding[0] == 0) {
                                        strncpy_s(pvar->settings.DefaultForwarding,
                                                  sizeof(pvar->settings.DefaultForwarding),
                                                  option + 5, _TRUNCATE);
                                } else {
                                        strncat_s(pvar->settings.DefaultForwarding,
                                                  sizeof(pvar->settings.DefaultForwarding),
                                                  ";", _TRUNCATE);
                                        strncat_s(pvar->settings.DefaultForwarding,
                                                  sizeof(pvar->settings.DefaultForwarding),
                                                  option + 5, _TRUNCATE);
                                }
                        } else if (MATCH_STR(option + 4, "-f=") == 0) {
                                read_ssh_options_from_user_file(pvar, option + 7);
                        } else if (MATCH_STR(option + 4, "-v") == 0) {
                                pvar->settings.LogLevel = LOG_LEVEL_VERBOSE;
                        } else if (_stricmp(option + 4, "-autologin") == 0 ||
                                   _stricmp(option + 4, "-autologon") == 0) {
                                pvar->settings.TryDefaultAuth = TRUE;

                        } else if (_stricmp(option + 4, "-acceptall") == 0) {
                                pvar->settings.LocalForwardingIdentityCheck = FALSE;

                        // -axx������������������
                        } else if (MATCH_STR(option + 4, "-a") == 0) {
                                pvar->settings.ForwardAgent = FALSE;
                        } else if (MATCH_STR(option + 4, "-A") == 0) {
                                pvar->settings.ForwardAgent = TRUE;

                        } else if (MATCH_STR(option + 4, "-consume=") == 0) {
                                read_ssh_options_from_user_file(pvar, option + 13);
                                DeleteFile(option + 13);

                        // /ssh1 �� /ssh2 �I�v�V�������V�K���� (2006.9.16 maya)
                        } else if (MATCH_STR(option + 4, "1") == 0) {
                                pvar->settings.Enabled = 1;
                                pvar->settings.ssh_protocol_version = 1;
                        } else if (MATCH_STR(option + 4, "2") == 0) {
                                pvar->settings.Enabled = 1;
                                pvar->settings.ssh_protocol_version = 2;

                        } else {
                                char buf[1024];

                                UTIL_get_lang_msg("MSG_UNKNOWN_OPTION_ERROR", pvar,
                                                  "Unrecognized command-line option: %s");
                                _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg, option);

                                MessageBox(NULL, buf, "TTSSH", MB_OK | MB_ICONEXCLAMATION);
                        }

                        return OPTION_CLEAR;

                // ttermpro.exe �� /T= �w�������p�������A������������ (2006.10.19 maya)
                } else if (MATCH_STR_I(option + 1, "t=") == 0) {
                        if (strcmp(option + 3, "2") == 0) {
                                pvar->settings.Enabled = 1;
                                return OPTION_CLEAR;
                        } else {
                                pvar->settings.Enabled = 0;
                        }

                // ttermpro.exe �� /F= �w������ TTSSH ������������ (2006.10.11 maya)
                } else if (MATCH_STR_I(option + 1, "f=") == 0) {
                        read_ssh_options_from_user_file(pvar, option + 3);

                // /1 ������ /2 �I�v�V�������V�K���� (2004.10.3 yutaka)
                } else if (MATCH_STR(option + 1, "1") == 0) {
                        // command line: /ssh /1 is SSH1 only
                        pvar->settings.ssh_protocol_version = 1;

                } else if (MATCH_STR(option + 1, "2") == 0) {
                        // command line: /ssh /2 is SSH2 & SSH1
                        pvar->settings.ssh_protocol_version = 2;

                } else if (MATCH_STR(option + 1, "nossh") == 0) {
                        // '/nossh' �I�v�V�����������B
                        // TERATERM.INI ��SSH���L�������������������A������Cygterm���N��������������
                        // �����������������B(2004.10.11 yutaka)
                        pvar->settings.Enabled = 0;

                } else if (MATCH_STR(option + 1, "telnet") == 0) {
                        // '/telnet' ���w�������������������� '/nossh' ��������
                        // SSH������������ (2006.9.16 maya)
                        pvar->settings.Enabled = 0;

                } else if (MATCH_STR(option + 1, "auth") == 0) {
                        // SSH2�������O�C���I�v�V����������
                        //
                        // SYNOPSIS: /ssh /auth=passowrd /user=���[�U�� /passwd=�p�X���[�h
                        //           /ssh /auth=publickey /user=���[�U�� /passwd=�p�X���[�h /keyfile=�p�X
                        // EXAMPLE: /ssh /auth=password /user=nike /passwd=a@bc
                        //          /ssh /auth=publickey /user=foo /passwd=bar /keyfile=d:\tmp\id_rsa
                        // NOTICE: �p�X���[�h���p�X�������������������A�u�����N���������� @ ���g�������B
                        //
                        // (2004.11.30 yutaka)
                        // (2005.1.26 yutaka) ���������B���J���F���T�|�[�g�B
                        //
                        pvar->ssh2_autologin = 1; // for SSH2 (2004.11.30 yutaka)

                        if (MATCH_STR(option + 5, "=password") == 0) { // �p�X���[�h
                                //pvar->auth_state.cur_cred.method = SSH_AUTH_PASSWORD;
                                pvar->ssh2_authmethod = SSH_AUTH_PASSWORD;

                        // /auth=challenge ������ (2007.10.5 maya)
                        } else if (MATCH_STR(option + 5, "=challenge") == 0) { // keyboard-interactive�F��
                                //pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
                                pvar->ssh2_authmethod = SSH_AUTH_TIS;

                        } else if (MATCH_STR(option + 5, "=publickey") == 0) { // ���J���F��
                                //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
                                pvar->ssh2_authmethod = SSH_AUTH_RSA;

                        } else if (MATCH_STR(option + 5, "=pageant") == 0) { // ���J���F�� by Pageant
                                //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
                                pvar->ssh2_authmethod = SSH_AUTH_PAGEANT;

                        } else {
                                // TODO:

                        }

                } else if (MATCH_STR(option + 1, "user=") == 0) {
                        replace_to_blank(option + 6, pvar->ssh2_username, sizeof(pvar->ssh2_username));
                        //_snprintf(pvar->ssh2_username, sizeof(pvar->ssh2_username), "%s", option + 6);

                } else if (MATCH_STR(option + 1, "passwd=") == 0) {
                        replace_to_blank(option + 8, pvar->ssh2_password, sizeof(pvar->ssh2_password));
                        //_snprintf(pvar->ssh2_password, sizeof(pvar->ssh2_password), "%s", option + 8);

                } else if (MATCH_STR(option + 1, "keyfile=") == 0) {
                        replace_to_blank(option + 9, pvar->ssh2_keyfile, sizeof(pvar->ssh2_keyfile));

                } else if (MATCH_STR(option + 1, "ask4passwd") == 0) {
                        // �p�X���[�h������ (2006.9.18 maya)
                        pvar->ask4passwd = 1;

                }

                // �p�X���[�h�������������������O�C��������������
                // /auth ���F�����\�b�h���w�������������p������ (2006.9.18 maya)
                if (pvar->ask4passwd == 1) {
                        pvar->ssh2_autologin = 0;
                }

        }
        else if ((MATCH_STR_I(option, "ssh://") == 0) ||
                 (MATCH_STR_I(option, "ssh1://") == 0) ||
                 (MATCH_STR_I(option, "ssh2://") == 0) ||
                 (MATCH_STR_I(option, "slogin://") == 0) ||
                 (MATCH_STR_I(option, "slogin1://") == 0) ||
                 (MATCH_STR_I(option, "slogin2://") == 0)) {
                //
                // ssh://user@host/ ����URL�`�����T�|�[�g
                // ���{�I�������� telnet:// URL��������
                //
                // �Q�l:
                //   RFC3986: Uniform Resource Identifier (URI): Generic Syntax
                //   RFC4248: The telnet URI Scheme
                //
                char *p, *p2, *p3;
                int optlen, hostlen;

                optlen = strlen(option);

                // ������':'���O�����������������������A������ssh�v���g�R���o�[�W������������
                p = strchr(option, ':');
                switch (*(p-1)) {
                case '1':
                        pvar->settings.ssh_protocol_version = 1;
                        break;
                case '2':
                        pvar->settings.ssh_protocol_version = 2;
                        break;
                }

                // authority part �����|�C���^������
                p += 3;

                // path part ������������
                if ((p2 = strchr(p, '/')) != NULL) {
                        *p2 = 0;
                }

                // '@'�������������A���������O�����[�U����
                if ((p2 = strchr(p, '@')) != NULL) {
                        *p2 = 0;
                        // ':'���~���p�X���[�h
                        if ((p3 = strchr(p, ':')) != NULL) {
                                *p3 = 0;
                                percent_decode(pvar->ssh2_password, sizeof(pvar->ssh2_password), p3 + 1);
                                pvar->ssh2_autologin = 1;
                        }
                        percent_decode(pvar->ssh2_username, sizeof(pvar->ssh2_username), p);
                        // p �� host part ������('@'����������)����������������
                        p = p2 + 1;
                }

                // host part �� option �����������������Ascheme part ������
                // port�w����������������port���������������������m��������������
                hostlen = strlen(p);
                memmove_s(option, optlen, p, hostlen);
                option[hostlen] = 0;

                // �|�[�g�w������������":22"������
#ifndef NO_INET6
                if (option[0] == '[' && option[hostlen-1] == ']' ||     // IPv6 raw address without port
                    option[0] != '[' && strchr(option, ':') == NULL) {  // hostname or IPv4 raw address without port
#else
                if (strchr(option, ':') == NULL) {
#endif                                                  /* NO_INET6 */
                        memcpy_s(option+hostlen, optlen-hostlen, ":22", 3);
                        hostlen += 3;
                }

                // �|�[�g�w�����������������X�y�[�X������
                memset(option+hostlen, ' ', optlen-hostlen);

                pvar->settings.Enabled = 1;

                return OPTION_REPLACE;
        }
        else if (strchr(option, '@') != NULL) {
                //
                // user@host �`�����T�|�[�g
                //   ����������ssh�������T�|�[�g�����A���[�U����ttssh���������B
                //   (ssh�������O --  ttssh�������W������������)
                //   �����I��telnet authentication option���T�|�[�g��������
                //   Tera Term�{�����������������������\���B
                //
                char *p;
                p = strchr(option, '@');
                *p = 0;

                strncpy_s(pvar->ssh2_username, sizeof(pvar->ssh2_username), option, _TRUNCATE);

                // ���[�U���������X�y�[�X�������B
                // ������TTX��Tera Term�{�������������������X�y�[�X�����������������A
                // �z�X�g�����������l�����K�v�������B
                memset(option, ' ', p-option+1);

                return OPTION_REPLACE;
        }

        return OPTION_NONE;
}

static void FAR PASCAL TTXParseParam(PCHAR param, PTTSet ts,
                                     PCHAR DDETopic)
{
        // �X�y�[�X�������t�@�C�������F�������������C�� (2006.10.7 maya)
        int i, buflen;
        BOOL inParam = FALSE;
        BOOL inQuotes = FALSE;
        BOOL inFileParam = FALSE;
        PCHAR option = NULL;

        if (pvar->hostdlg_activated) {
                pvar->settings.Enabled = pvar->hostdlg_Enabled;
        }

        for (i = 0; param[i] != 0; i++) {
                if (inQuotes ? param[i] == '"'
                             : (param[i] == ' ' || param[i] == '\t')) {
                        if (option != NULL) {
                                char ch = param[i];
                                PCHAR Equal;

                                param[i] = 0;
                                Equal = strchr(option, '=');
                                if (inFileParam && Equal != NULL && *(Equal + 1) == '"') {
                                        int buf_len = strlen(option) * sizeof(char);
                                        char *buf = (char *)calloc(strlen(option), sizeof(char));
                                        char c = option[Equal - option + 1];
                                        option[Equal - option + 1] = 0;
                                        strncat_s(buf, buf_len, option, _TRUNCATE);
                                        option[Equal - option + 1] = c;
                                        strncat_s(buf, buf_len, Equal + 2, _TRUNCATE);
                                        switch (parse_option(pvar, *buf == '"' ? buf + 1 : buf)) {
                                          case OPTION_CLEAR:
                                                memset(option, ' ', i + 1 - (option - param));
                                                break;
                                          case OPTION_REPLACE:
                                                buflen = strlen(buf);
                                                memcpy(option, buf, buflen);
                                                memset(option + buflen, ' ', i + 1 - buflen - (option - param));
                                                break;
                                          default:
                                                param[i] = ch;
                                        }
                                        free(buf);
                                }
                                else {
                                        switch (parse_option(pvar, *option == '"' ? option + 1 : option)) {
                                          case OPTION_CLEAR:
                                                memset(option, ' ', i + 1 - (option - param));
                                                break;
                                          default:
                                                param[i] = ch;
                                        }
                                }
                                option = NULL;
                        }
                        inParam = FALSE;
                        inQuotes = FALSE;
                        inFileParam = FALSE;
                } else if (!inParam) {
                        if (param[i] == '"') {
                                inQuotes = TRUE;
                                inParam = TRUE;
                                option = param + i;
                        } else if (param[i] != ' ' && param[i] != '\t') {
                                inParam = TRUE;
                                option = param + i;
                        }
                } else {
                        if (option == NULL) {
                                continue;
                        }
                        if ((option[0] == '-' || option[0] == '/') &&
                            (MATCH_STR(option + 1, "ssh-f=") == 0 ||
                             MATCH_STR(option + 1, "ssh-consume=") == 0 ||
                             MATCH_STR_I(option + 1, "f=") == 0 ||
                             MATCH_STR(option + 1, "keyfile=") == 0)) {
                                if (param[i] == '"') {
                                        inQuotes = TRUE;
                                }
                                inFileParam = TRUE;
                        }
                }
        }

        if (option != NULL) {
                PCHAR Equal = strchr(option, '=');
                if (inFileParam && Equal != NULL && *(Equal + 1) == '"') {
                        int buf_len = strlen(option) * sizeof(char);
                        char *buf = (char *)calloc(strlen(option), sizeof(char));
                        char c = option[Equal - option + 1];
                        option[Equal - option + 1] = 0;
                        strncat_s(buf, buf_len, option, _TRUNCATE);
                        option[Equal - option + 1] = c;
                        strncat_s(buf, buf_len, Equal + 2, _TRUNCATE);
                        switch (parse_option(pvar, *buf == '"' ? buf + 1 : buf)) {
                          case OPTION_CLEAR:
                                memset(option, ' ', i + 1 - (option - param));
                                break;
                          case OPTION_REPLACE:
                                strcpy_s(option, i - (param - option), buf);
                                break;
                        }
                        free(buf);
                }
                else {
                        switch (parse_option(pvar, option)) {
                          case OPTION_CLEAR:
                                memset(option, ' ', i - (option - param));
                                break;
                        }
                }
        }

        FWDUI_load_settings(pvar);

        (pvar->ParseParam) (param, ts, DDETopic);

}

static void PASCAL FAR TTXGetSetupHooks(TTXSetupHooks FAR * hooks)
{
        pvar->ReadIniFile = *hooks->ReadIniFile;
        pvar->WriteIniFile = *hooks->WriteIniFile;
        pvar->ParseParam = *hooks->ParseParam;

        *hooks->ReadIniFile = TTXReadINIFile;
        *hooks->WriteIniFile = TTXWriteINIFile;
        *hooks->ParseParam = TTXParseParam;
}

static void PASCAL FAR TTXSetWinSize(int rows, int cols)
{
        SSH_notify_win_size(pvar, cols, rows);
}

static void insertMenuBeforeItem(HMENU menu, WORD beforeItemID, WORD flags,
                                 WORD newItemID, char FAR * text)
{
        int i, j;

        for (i = GetMenuItemCount(menu) - 1; i >= 0; i--) {
                HMENU submenu = GetSubMenu(menu, i);

                for (j = GetMenuItemCount(submenu) - 1; j >= 0; j--) {
                        if (GetMenuItemID(submenu, j) == beforeItemID) {
                                InsertMenu(submenu, j, MF_BYPOSITION | flags, newItemID, text);
                                return;
                        }
                }
        }
}

static void PASCAL FAR TTXModifyMenu(HMENU menu)
{
        /* inserts before ID_HELP_ABOUT */
        UTIL_get_lang_msg("MENU_ABOUT", pvar, "About &TTSSH...");
        insertMenuBeforeItem(menu, 50990, MF_ENABLED, ID_ABOUTMENU, pvar->ts->UIMsg);

        /* inserts before ID_SETUP_TCPIP */
        UTIL_get_lang_msg("MENU_SSH", pvar, "SS&H...");
        insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHSETUPMENU, pvar->ts->UIMsg);
        /* inserts before ID_SETUP_TCPIP */
        UTIL_get_lang_msg("MENU_SSH_AUTH", pvar, "SSH &Authentication...");
        insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHAUTHSETUPMENU, pvar->ts->UIMsg);
        /* inserts before ID_SETUP_TCPIP */
        UTIL_get_lang_msg("MENU_SSH_FORWARD", pvar, "SSH F&orwarding...");
        insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHFWDSETUPMENU, pvar->ts->UIMsg);
        UTIL_get_lang_msg("MENU_SSH_KEYGEN", pvar, "SSH KeyGe&nerator...");
        insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHKEYGENMENU, pvar->ts->UIMsg);

        /* inserts before ID_FILE_CHANGEDIR */
        UTIL_get_lang_msg("MENU_SSH_SCP", pvar, "SS&H SCP...");
        insertMenuBeforeItem(menu, 50170, MF_ENABLED, ID_SSHSCPMENU, pvar->ts->UIMsg);
}

static void append_about_text(HWND dlg, char FAR * prefix, char FAR * msg)
{
        SendDlgItemMessage(dlg, IDC_ABOUTTEXT, EM_REPLACESEL, 0,
                           (LPARAM) prefix);
        SendDlgItemMessage(dlg, IDC_ABOUTTEXT, EM_REPLACESEL, 0, (LPARAM) msg);
        SendDlgItemMessage(dlg, IDC_ABOUTTEXT, EM_REPLACESEL, 0,
                           (LPARAM) (char FAR *) "\r\n");
}

// ���s�t�@�C�������o�[�W�������������� (2005.2.28 yutaka)
void get_file_version(char *exefile, int *major, int *minor, int *release, int *build)
{
        typedef struct {
                WORD wLanguage;
                WORD wCodePage;
        } LANGANDCODEPAGE, *LPLANGANDCODEPAGE;
        LPLANGANDCODEPAGE lplgcode;
        UINT unLen;
        DWORD size;
        char *buf = NULL;
        BOOL ret;
        int i;
        char fmt[80];
        char *pbuf;

        size = GetFileVersionInfoSize(exefile, NULL);
        if (size == 0) {
                goto error;
        }
        buf = malloc(size);
        ZeroMemory(buf, size);

        if (GetFileVersionInfo(exefile, 0, size, buf) == FALSE) {
                goto error;
        }

        ret = VerQueryValue(buf,
                        "\\VarFileInfo\\Translation",
                        (LPVOID *)&lplgcode, &unLen);
        if (ret == FALSE)
                goto error;

        for (i = 0 ; i < (int)(unLen / sizeof(LANGANDCODEPAGE)) ; i++) {
                _snprintf_s(fmt, sizeof(fmt), _TRUNCATE,
                            "\\StringFileInfo\\%04x%04x\\FileVersion",
                            lplgcode[i].wLanguage, lplgcode[i].wCodePage);
                VerQueryValue(buf, fmt, &pbuf, &unLen);
                if (unLen > 0) { // get success
                        int n, a, b, c, d;

                        n = sscanf(pbuf, "%d, %d, %d, %d", &a, &b, &c, &d);
                        if (n == 4) { // convert success
                                *major = a;
                                *minor = b;
                                *release = c;
                                *build = d;
                                break;
                        }
                }
        }

        free(buf);
        return;

error:
        free(buf);
        *major = *minor = *release = *build = 0;
}

static void init_about_dlg(PTInstVar pvar, HWND dlg)
{
        char buf[1024];
        int a, b, c, d;
        char uimsg[MAX_UIMSG];

        GetWindowText(dlg, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("DLG_ABOUT_TITLE", pvar, uimsg);
        SetWindowText(dlg, pvar->ts->UIMsg);
        GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
        SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);

        // TTSSH���o�[�W�������������� (2005.2.28 yutaka)
        get_file_version("ttxssh.dll", &a, &b, &c, &d);
        _snprintf_s(buf, sizeof(buf), _TRUNCATE,
                "TTSSH\r\nTera Term Secure Shell extension, %d.%d", a, b);
        SendMessage(GetDlgItem(dlg, IDC_TTSSH_VERSION), WM_SETTEXT, 0, (LPARAM)buf);

        // OpenSSL���o�[�W�������������� (2005.1.24 yutaka)
        // ���������� (2005.5.11 yutaka)
#ifdef OPENSSL_VERSION_TEXT
        SendMessage(GetDlgItem(dlg, IDC_OPENSSL_VERSION), WM_SETTEXT, 0, (LPARAM)OPENSSL_VERSION_TEXT);
#else
        SendMessage(GetDlgItem(dlg, IDC_OPENSSL_VERSION), WM_SETTEXT, 0, (LPARAM)"Unknown");
#endif

        // zlib���o�[�W�������������� (2005.5.11 yutaka)
#ifdef ZLIB_VERSION
        _snprintf_s(buf, sizeof(buf), _TRUNCATE, "ZLib %s", ZLIB_VERSION);
#else
        _snprintf(buf, sizeof(buf), "ZLib Unknown");
#endif
        SendMessage(GetDlgItem(dlg, IDC_ZLIB_VERSION), WM_SETTEXT, 0, (LPARAM)buf);


        // TTSSH�_�C�A���O���\������SSH������������ (2004.10.30 yutaka)
        if (pvar->socket != INVALID_SOCKET) {
                if (SSHv1(pvar)) {
                        SSH_get_server_ID_info(pvar, buf, sizeof(buf));
                        UTIL_get_lang_msg("DLG_ABOUT_SERVERID", pvar, "Server ID:");
                        append_about_text(dlg, pvar->ts->UIMsg, buf);
                        SSH_get_protocol_version_info(pvar, buf, sizeof(buf));
                        UTIL_get_lang_msg("DLG_ABOUT_PROTOCOL", pvar, "Using protocol:");
                        append_about_text(dlg, pvar->ts->UIMsg, buf);
                        CRYPT_get_cipher_info(pvar, buf, sizeof(buf));
                        UTIL_get_lang_msg("DLG_ABOUT_ENCRYPTION", pvar, "Encryption:");
                        append_about_text(dlg, pvar->ts->UIMsg, buf);
                        CRYPT_get_server_key_info(pvar, buf, sizeof(buf));
                        UTIL_get_lang_msg("DLG_ABOUT_SERVERKEY", pvar, "Server keys:");
                        append_about_text(dlg, pvar->ts->UIMsg, buf);
                        AUTH_get_auth_info(pvar, buf, sizeof(buf));
                        UTIL_get_lang_msg("DLG_ABOUT_AUTH", pvar, "Authentication:");
                        append_about_text(dlg, pvar->ts->UIMsg, buf);
                        SSH_get_compression_info(pvar, buf, sizeof(buf));
                        UTIL_get_lang_msg("DLG_ABOUT_COMP", pvar, "Compression:");
                        append_about_text(dlg, pvar->ts->UIMsg, buf);

                } else { // SSH2
                        SSH_get_server_ID_info(pvar, buf, sizeof(buf));
                        UTIL_get_lang_msg("DLG_ABOUT_SERVERID", pvar, "Server ID:");
                        append_about_text(dlg, pvar->ts->UIMsg, buf);
                        UTIL_get_lang_msg("DLG_ABOUT_CLIENTID", pvar, "Client ID:");
                        append_about_text(dlg, pvar->ts->UIMsg, pvar->client_version_string);

                        SSH_get_protocol_version_info(pvar, buf, sizeof(buf));
                        UTIL_get_lang_msg("DLG_ABOUT_PROTOCOL", pvar, "Using protocol:");
                        append_about_text(dlg, pvar->ts->UIMsg, buf);

                        if (pvar->kex_type == KEX_DH_GRP1_SHA1) {
                                strncpy_s(buf, sizeof(buf), KEX_DH1, _TRUNCATE);
                        } else if (pvar->kex_type == KEX_DH_GRP14_SHA1) {
                                strncpy_s(buf, sizeof(buf), KEX_DH14, _TRUNCATE);
                        } else {
                                strncpy_s(buf, sizeof(buf), KEX_DHGEX, _TRUNCATE);
                        }
                        append_about_text(dlg, "KEX:", buf);

                        if (pvar->hostkey_type == KEY_DSA) {
                                strncpy_s(buf, sizeof(buf), "ssh-dss", _TRUNCATE);
                        } else {
                                strncpy_s(buf, sizeof(buf), "ssh-rsa", _TRUNCATE);
                        }
                        UTIL_get_lang_msg("DLG_ABOUT_HOSTKEY", pvar, "Host Key:");
                        append_about_text(dlg, pvar->ts->UIMsg, buf);

                        // add HMAC algorithm (2004.12.17 yutaka)
                        buf[0] = '\0';
                        if (pvar->ctos_hmac == HMAC_SHA1) {
                                strncat_s(buf, sizeof(buf), "hmac-sha1", _TRUNCATE);
                        } else if (pvar->ctos_hmac == HMAC_MD5) {
                                strncat_s(buf, sizeof(buf), "hmac-md5", _TRUNCATE);
                        }
                        UTIL_get_lang_msg("DLG_ABOUT_TOSERVER", pvar, " to server,");
                        strncat_s(buf, sizeof(buf), pvar->ts->UIMsg, _TRUNCATE);
                        if (pvar->stoc_hmac == HMAC_SHA1) {
                                strncat_s(buf, sizeof(buf), "hmac-sha1", _TRUNCATE);
                        } else if (pvar->stoc_hmac == HMAC_MD5) {
                                strncat_s(buf, sizeof(buf), "hmac-md5", _TRUNCATE);
                        }
                        UTIL_get_lang_msg("DLG_ABOUT_FROMSERVER", pvar, " from server");
                        strncat_s(buf, sizeof(buf), pvar->ts->UIMsg, _TRUNCATE);
                        append_about_text(dlg, "HMAC:", buf);

                        CRYPT_get_cipher_info(pvar, buf, sizeof(buf));
                        UTIL_get_lang_msg("DLG_ABOUT_ENCRYPTION", pvar, "Encryption:");
                        append_about_text(dlg, pvar->ts->UIMsg, buf);
                        CRYPT_get_server_key_info(pvar, buf, sizeof(buf));
                        UTIL_get_lang_msg("DLG_ABOUT_SERVERKEY", pvar, "Server keys:");
                        append_about_text(dlg, pvar->ts->UIMsg, buf);

                        AUTH_get_auth_info(pvar, buf, sizeof(buf));
                        UTIL_get_lang_msg("DLG_ABOUT_AUTH", pvar, "Authentication:");
                        append_about_text(dlg, pvar->ts->UIMsg, buf);

                        SSH_get_compression_info(pvar, buf, sizeof(buf));
                        if (pvar->ctos_compression == COMP_DELAYED) { // �x���p�P�b�g���k������ (2006.6.23 yutaka)
                                UTIL_get_lang_msg("DLG_ABOUT_COMPDELAY", pvar, "Delayed Compression:");
                                append_about_text(dlg, pvar->ts->UIMsg, buf);
                        } else {
                                UTIL_get_lang_msg("DLG_ABOUT_COMP", pvar, "Compression:");
                                append_about_text(dlg, pvar->ts->UIMsg, buf);
                        }
                }
        }
}

static BOOL CALLBACK TTXAboutDlg(HWND dlg, UINT msg, WPARAM wParam,
                                 LPARAM lParam)
{
        LOGFONT logfont;
        HFONT font;

        switch (msg) {
        case WM_INITDIALOG:
                font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
                GetObject(font, sizeof(LOGFONT), &logfont);
                if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAboutFont, pvar)) {
                        SendDlgItemMessage(dlg, IDC_TTSSH_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_SSHVERSIONS, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_INCLUDES, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_OPENSSL_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_ZLIB_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_WEBSITES, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_CRYPTOGRAPHY, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_CREDIT, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDC_ABOUTTEXT, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
                        SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
                }
                else {
                        DlgAboutFont = NULL;
                }

                // �A�C�R�������I���Z�b�g
                {
                        int fuLoad = LR_DEFAULTCOLOR;
                        HICON hicon;

                        if (is_NT4()) {
                                fuLoad = LR_VGACOLOR;
                        }

                        hicon = LoadImage(hInst, MAKEINTRESOURCE(IDI_SECURETT),
                                          IMAGE_ICON, 32, 32, fuLoad);
                        SendDlgItemMessage(dlg, IDC_TTSSH_ICON, STM_SETICON, (WPARAM)hicon, 0);
                }

                init_about_dlg((PTInstVar) lParam, dlg);
                return TRUE;
        case WM_COMMAND:
                switch (LOWORD(wParam)) {
                case IDOK:
                        EndDialog(dlg, 1);
                        if (DlgAboutFont != NULL) {
                                DeleteObject(DlgAboutFont);
                        }
                        return TRUE;
                case IDCANCEL:                  /* there isn't a cancel button, but other Windows
                                                                   UI things can send this message */
                        EndDialog(dlg, 0);
                        if (DlgAboutFont != NULL) {
                                DeleteObject(DlgAboutFont);
                        }
                        return TRUE;
                }
                break;
        }

        return FALSE;
}

static char FAR *get_cipher_name(int cipher)
{
        switch (cipher) {
        case SSH_CIPHER_NONE:
                UTIL_get_lang_msg("DLG_SSHSETUP_CIPHER_BORDER", pvar,
                                  "<ciphers below this line are disabled>");
                return pvar->ts->UIMsg;
        case SSH_CIPHER_RC4:
                return "RC4(SSH1)";
        case SSH_CIPHER_3DES:
                return "3DES(SSH1)";
        case SSH_CIPHER_DES:
                return "DES(SSH1)";
        case SSH_CIPHER_IDEA:
                return "IDEA(SSH1)";
        case SSH_CIPHER_TSS:
                return "TSS(SSH1)";
        case SSH_CIPHER_BLOWFISH:
                return "Blowfish(SSH1)";

        // for SSH2(yutaka)
        case SSH2_CIPHER_AES128_CBC:
                return "AES128-CBC(SSH2)";
        case SSH2_CIPHER_AES192_CBC:
                return "AES192-CBC(SSH2)";
        case SSH2_CIPHER_AES256_CBC:
                return "AES256-CBC(SSH2)";
        case SSH2_CIPHER_3DES_CBC:
                return "3DES-CBC(SSH2)";
        case SSH2_CIPHER_BLOWFISH_CBC:
                return "Blowfish-CBC(SSH2)";
        case SSH2_CIPHER_AES128_CTR:
                return "AES128-CTR(SSH2)";
        case SSH2_CIPHER_AES192_CTR:
                return "AES192-CTR(SSH2)";
        case SSH2_CIPHER_AES256_CTR:
                return "AES256-CTR(SSH2)";
        case SSH2_CIPHER_ARCFOUR:
                return "Arcfour(SSH2)";
        case SSH2_CIPHER_ARCFOUR128:
                return "Arcfour128(SSH2)";
        case SSH2_CIPHER_ARCFOUR256:
                return "Arcfour256(SSH2)";
        case SSH2_CIPHER_CAST128_CBC:
                return "CAST128-CBC(SSH2)";

        default:
                return NULL;
        }
}

static void set_move_button_status(HWND dlg)
{
        HWND cipherControl = GetDlgItem(dlg, IDC_SSHCIPHERPREFS);
        int curPos = (int) SendMessage(cipherControl, LB_GETCURSEL, 0, 0);
        int maxPos = (int) SendMessage(cipherControl, LB_GETCOUNT, 0, 0) - 1;

        EnableWindow(GetDlgItem(dlg, IDC_SSHMOVECIPHERUP),
                     curPos > 0 && curPos <= maxPos);
        EnableWindow(GetDlgItem(dlg, IDC_SSHMOVECIPHERDOWN),
                     curPos >= 0 && curPos < maxPos);
}

static void init_setup_dlg(PTInstVar pvar, HWND dlg)
{
        HWND compressionControl = GetDlgItem(dlg, IDC_SSHCOMPRESSIONLEVEL);
        HWND cipherControl = GetDlgItem(dlg, IDC_SSHCIPHERPREFS);
        int i;
        int ch;
        char uimsg[MAX_UIMSG];

        GetWindowText(dlg, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("DLG_SSHSETUP_TITLE", pvar, uimsg);
        SetWindowText(dlg, pvar->ts->UIMsg);
        GetDlgItemText(dlg, IDC_COMPRESSLABEL, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS", pvar, uimsg);
        SetDlgItemText(dlg, IDC_COMPRESSLABEL, pvar->ts->UIMsg);
        GetDlgItemText(dlg, IDC_COMPRESSNONE, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS_NONE", pvar, uimsg);
        SetDlgItemText(dlg, IDC_COMPRESSNONE, pvar->ts->UIMsg);
        GetDlgItemText(dlg, IDC_COMPRESSHIGH, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS_HIGHEST", pvar, uimsg);
        SetDlgItemText(dlg, IDC_COMPRESSHIGH, pvar->ts->UIMsg);
        GetDlgItemText(dlg, IDC_CIPHERORDER, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("DLG_SSHSETUP_CHIPER", pvar, uimsg);
        SetDlgItemText(dlg, IDC_CIPHERORDER, pvar->ts->UIMsg);
        GetDlgItemText(dlg, IDC_SSHMOVECIPHERUP, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("DLG_SSHSETUP_CHIPER_UP", pvar, uimsg);
        SetDlgItemText(dlg, IDC_SSHMOVECIPHERUP, pvar->ts->UIMsg);
        GetDlgItemText(dlg, IDC_SSHMOVECIPHERDOWN, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("DLG_SSHSETUP_CHIPER_DOWN", pvar, uimsg);
        SetDlgItemText(dlg, IDC_SSHMOVECIPHERDOWN, pvar->ts->UIMsg);
        GetDlgItemText(dlg, IDC_KNOWNHOSTS, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST", pvar, uimsg);
        SetDlgItemText(dlg, IDC_KNOWNHOSTS, pvar->ts->UIMsg);
        GetDlgItemText(dlg, IDC_CHOOSEREADWRITEFILE, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST_RW", pvar, uimsg);
        SetDlgItemText(dlg, IDC_CHOOSEREADWRITEFILE, pvar->ts->UIMsg);
        GetDlgItemText(dlg, IDC_CHOOSEREADONLYFILE, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST_RO", pvar, uimsg);
        SetDlgItemText(dlg, IDC_CHOOSEREADONLYFILE, pvar->ts->UIMsg);
        GetDlgItemText(dlg, IDC_HEARTBEATLABEL, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("DLG_SSHSETUP_HEARTBEAT", pvar, uimsg);
        SetDlgItemText(dlg, IDC_HEARTBEATLABEL, pvar->ts->UIMsg);
        GetDlgItemText(dlg, IDC_HEARTBEATLABEL2, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("DLG_SSHSETUP_HEARTBEAT_UNIT", pvar, uimsg);
        SetDlgItemText(dlg, IDC_HEARTBEATLABEL2, pvar->ts->UIMsg);
        GetDlgItemText(dlg, IDC_FORWARDAGENT, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("DLG_SSHSETUP_FORWARDAGENT", pvar, uimsg);
        SetDlgItemText(dlg, IDC_FORWARDAGENT, pvar->ts->UIMsg);
        GetDlgItemText(dlg, IDC_NOTICEBANNER, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("DLG_SSHSETUP_NOTICE", pvar, uimsg);
        SetDlgItemText(dlg, IDC_NOTICEBANNER, pvar->ts->UIMsg);
        GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
        SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
        GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
        UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
        SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
