ttssh2/ttxssh/ssh.c

/*
Copyright (c) 1998-2001, Robert O'Callahan
Copyright (c) 2004-2005, Yutaka Hirata
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.
*/

#include "ttxssh.h"
#include "util.h"

#include <openssl/bn.h>
#include <openssl/evp.h>
#include <openssl/dh.h>
#include <openssl/engine.h>
#include <openssl/rsa.h>
#include <openssl/dsa.h>
#include <limits.h>
#include <malloc.h>
#include <string.h>
#include <stdlib.h>
#include <process.h>
#include <time.h>
#include "buffer.h"
#include "ssh.h"
#include "crypt.h"

// SSH2 macro
#ifdef _DEBUG
#define SSH2_DEBUG
#endif

#define DONT_WANTCONFIRM 1  // (2005.3.28 yutaka)
#define INTBLOB_LEN 20
#define SIGBLOB_LEN (2*INTBLOB_LEN)

static char ssh_ttymodes[] = "\x01\x03\x02\x1c\x03\x08\x04\x15\x05\x04";

static void try_send_credentials(PTInstVar pvar);
static void prep_compression(PTInstVar pvar);

// �����v���g�^�C�v����
void SSH2_send_kexinit(PTInstVar pvar);
static BOOL handle_SSH2_kexinit(PTInstVar pvar);
static void SSH2_dh_kex_init(PTInstVar pvar);
static void SSH2_dh_gex_kex_init(PTInstVar pvar);
static BOOL handle_SSH2_dh_common_reply(PTInstVar pvar);
static BOOL handle_SSH2_dh_gex_reply(PTInstVar pvar);
static BOOL handle_SSH2_newkeys(PTInstVar pvar);
static BOOL handle_SSH2_authrequest(PTInstVar pvar);
static BOOL handle_SSH2_userauth_success(PTInstVar pvar);
static BOOL handle_SSH2_userauth_failure(PTInstVar pvar);
static BOOL handle_SSH2_userauth_banner(PTInstVar pvar);
static BOOL handle_SSH2_open_confirm(PTInstVar pvar);
static BOOL handle_SSH2_request_success(PTInstVar pvar);
static BOOL handle_SSH2_channel_success(PTInstVar pvar);
static BOOL handle_SSH2_channel_data(PTInstVar pvar);
static BOOL handle_SSH2_channel_extended_data(PTInstVar pvar);
static BOOL handle_SSH2_channel_eof(PTInstVar pvar);
static BOOL handle_SSH2_channel_close(PTInstVar pvar);
static BOOL handle_SSH2_window_adjust(PTInstVar pvar);
static BOOL handle_SSH2_channel_request(PTInstVar pvar);
void SSH2_dispatch_init(int stage);
int SSH2_dispatch_enabled_check(unsigned char message);
void SSH2_dispatch_add_message(unsigned char message);
void SSH2_dispatch_add_range_message(unsigned char begin, unsigned char end);
int dh_pub_is_valid(DH *dh, BIGNUM *dh_pub);
static void start_ssh_heartbeat_thread(PTInstVar pvar);


//
// SSH2 data structure
//

/* default window/packet sizes for tcp/x11-fwd-channel */
#define CHAN_SES_PACKET_DEFAULT (32*1024)
#define CHAN_SES_WINDOW_DEFAULT (2*CHAN_SES_PACKET_DEFAULT) // READAMOUNT @ pkt.c����������������

// channel data structure
#define CHANNEL_MAX 100

typedef struct channel {
        int used;
        int type;
        int self_id;
        int remote_id;
        unsigned int local_window;
        unsigned int local_window_max;
        unsigned int local_consumed;
        unsigned int local_maxpacket;
        unsigned int remote_window;
        unsigned int remote_maxpacket;
} Channel_t;

static Channel_t channels[CHANNEL_MAX];

//
// channel function
//
static Channel_t *ssh2_channel_new(unsigned int window, unsigned int maxpack)
{
        int i, found;
        Channel_t *c;

        found = -1;
        for (i = 0 ; i < CHANNEL_MAX ; i++) {
                if (channels[i].used == 0) { // free channel
                        found = i;
                        break;
                }
        }
        if (found == -1) { // not free channel
                return (NULL);
        }

        // setup
        c = &channels[found];
        c->used = 1;
        c->self_id = i;
        c->remote_id = -1;
        c->local_window = window;
        c->local_window_max = window;
        c->local_consumed = 0;
        c->local_maxpacket = maxpack;
        c->remote_window = 0;
        c->remote_maxpacket = 0;

        return (c);
}


// connection close������������
void ssh2_channel_free(void)
{
        int i;
        Channel_t *c;

        for (i = 0 ; i < CHANNEL_MAX ; i++) {
                c = &channels[i];
                memset(c, 0, sizeof(Channel_t));
        }

}

static Channel_t *ssh2_channel_lookup(int id)
{
        Channel_t *c;

        if (id < 0 || id >= CHANNEL_MAX) {
                return (NULL);
        }
        c = &channels[id];
        if (c->used == 0) { // already freed
                return (NULL);
        }
        return (c);
}


//
// SSH heartbeat mutex
//
static CRITICAL_SECTION g_ssh_heartbeat_lock;   /* ���b�N�p���� */

void ssh_heartbeat_lock_initialize(void)
{
        InitializeCriticalSection(&g_ssh_heartbeat_lock);
}

void ssh_heartbeat_lock_finalize(void)
{
        DeleteCriticalSection(&g_ssh_heartbeat_lock);
}

void ssh_heartbeat_lock(void)
{
        EnterCriticalSection(&g_ssh_heartbeat_lock);
}

void ssh_heartbeat_unlock(void)
{
        LeaveCriticalSection(&g_ssh_heartbeat_lock);
}


//
// SSH memory dump (for debug)
//
// (2005.3.7 yutaka)
//
#define MEMTAG_MAX 100
#define LOGDUMP "ssh2dump.log"
#define SENDTOME "Please send '"LOGDUMP"' file to TeraTerm developer team."

typedef struct memtag {
        char *name;
        char *desc;
        int len;
        char *data;
} memtag_t;

static memtag_t memtags[MEMTAG_MAX];
static int memtag_count = 0;
static int memtag_use = 0; 

/* �_���v���C�����t�H�[�}�b�g�\������ */
static void displine_memdump(FILE *fp, int addr, int *bytes, int byte_cnt)
{
        int i, c;

        /* �������A�h���X�\�� */
        fprintf(fp, "%08X : ", addr);

        /* �o�C�i���\���i4�o�C�g�������������}���j*/
        for (i = 0 ; i < byte_cnt ; i++) {
                if (i > 0 && i % 4 == 0)
                        fprintf(fp, " ");

                fprintf(fp, "%02X", bytes[i]);
        }

        /* ASCII�\���������������������� */
        fprintf(fp, "   %*s%*s", (16-byte_cnt)*2+1, " ", (16-byte_cnt+3)/4, " ");

        /* ASCII�\�� */
        for (i = 0 ; i < byte_cnt ; i++) {
                c = bytes[i];
                if (c >= 0x20 && c <= 0x7f) {
                        fprintf(fp, "%c", c);
                } else {
                        fprintf(fp, ".");
                }
        }

        fprintf(fp, "\n");
}


/* �_���v���[�`�� */
static void dump_memdump(FILE *fp, char *data, int len)
{
        int c, addr;
        int bytes[16], *ptr;
        int byte_cnt;
        int i;

        addr = 0;
        byte_cnt = 0;
        ptr = bytes;
        for (i = 0 ; i < len ; i++) {
                c = data[i];
                *ptr++ = c & 0xff;
                byte_cnt++;

                if (byte_cnt == 16) {
                        displine_memdump(fp, addr, bytes, byte_cnt);

                        addr += 16;
                        byte_cnt = 0;
                        ptr = bytes;
                }
        }

        if (byte_cnt > 0) {
                displine_memdump(fp, addr, bytes, byte_cnt);
        }
}

void init_memdump(void)
{
        int i;

        for (i = 0 ; i < MEMTAG_MAX ; i++) {
                memtags[i].name = NULL;
                memtags[i].desc = NULL;
                memtags[i].data = NULL;
                memtags[i].len = 0;
        }
        memtag_use++;
}

void finish_memdump(void)
{
        int i;

        // initialize�������������������������������B(2005.4.3 yutaka)
        if (memtag_use <= 0)
                return;
        memtag_use--;

        for (i = 0 ; i < MEMTAG_MAX ; i++) {
                free(memtags[i].name);
                free(memtags[i].desc);
                free(memtags[i].data);
                memtags[i].len = 0;
        }
}

void save_memdump(char *filename)
{
        FILE *fp;
        int i;
        time_t t;
        struct tm *tm;

        fp = fopen(filename, "w");
        if (fp == NULL)
                return;

        t = time(NULL);
        tm = localtime(&t);

        fprintf(fp, "<<< TeraTerm SSH2 log dump >>>\n");
        fprintf(fp, "saved time: %04d/%02d/%02d %02d:%02d:%02d\n",
                        tm->tm_year + 1900,
                        tm->tm_mon + 1,
                        tm->tm_mday,
                        tm->tm_hour,
                        tm->tm_min,
                        tm->tm_sec);
        fprintf(fp, "\n");

        for (i = 0 ; i < memtag_count ; i++) {
                fprintf(fp, "============================================\n");
                fprintf(fp, "name: %s\n", memtags[i].name);
                fprintf(fp, "--------------------------------------------\n");
                fprintf(fp, "description: %s\n", memtags[i].desc);
                fprintf(fp, "============================================\n");
                dump_memdump(fp, memtags[i].data, memtags[i].len);
                fprintf(fp, "\n\n\n");
        }

        fprintf(fp, "[EOF]\n");

        fclose(fp);
}

void push_memdump(char *name, char *desc, char *data, int len)
{
        memtag_t *ptr;
        char *dp;

        dp = malloc(len);
        if (dp == NULL)
                return;
        memcpy(dp, data, len);

        if (memtag_count >= MEMTAG_MAX)
                return;

        ptr = &memtags[memtag_count];
        memtag_count++;
        ptr->name = strdup(name);
        ptr->desc = strdup(desc);
        ptr->data = dp;
        ptr->len = len;
}

void push_bignum_memdump(char *name, char *desc, BIGNUM *bignum)
{
        int len;
        char *buf;

        len = BN_num_bytes(bignum);
        buf = malloc(len); // allocate
        if (buf == NULL)
                return;
        BN_bn2bin(bignum, buf);
        push_memdump(name, desc, buf, len); // at push_bignum_memdump()
        free(buf); // free
}


//
//
//


static int get_predecryption_amount(PTInstVar pvar)
{
        static int small_block_decryption_sizes[] = { 5, 5, 6, 6, 8 };

        if (SSHv1(pvar)) {
                return 0;
        } else {
                int block_size = CRYPT_get_decryption_block_size(pvar);

                if (block_size < 5) {
                        return small_block_decryption_sizes[block_size];
                } else {
                        return block_size;
                }
        }
}

/* Get up to 'limit' bytes into the payload buffer.
   'limit' is counted from the start of the payload data.
   Returns the amount of data in the payload buffer, or
   -1 if there is an error.
   We can return more than limit in some cases. */
static int buffer_packet_data(PTInstVar pvar, int limit)
{
        if (pvar->ssh_state.payloadlen >= 0) {
                return pvar->ssh_state.payloadlen;
        } else {
                int cur_decompressed_bytes =
                        pvar->ssh_state.decompress_stream.next_out -
                        pvar->ssh_state.postdecompress_inbuf;

                while (limit > cur_decompressed_bytes) {
                        int result;

                        pvar->ssh_state.payload =
                                pvar->ssh_state.postdecompress_inbuf + 1;
                        if (pvar->ssh_state.postdecompress_inbuflen ==
                                cur_decompressed_bytes) {
                                buf_ensure_size(&pvar->ssh_state.postdecompress_inbuf,
                                                                &pvar->ssh_state.postdecompress_inbuflen,
                                                                min(limit, cur_decompressed_bytes * 2));
                        }

                        pvar->ssh_state.decompress_stream.next_out
                                =
                                pvar->ssh_state.postdecompress_inbuf +
                                cur_decompressed_bytes;
                        pvar->ssh_state.decompress_stream.avail_out =
                                min(limit, pvar->ssh_state.postdecompress_inbuflen)
                                - cur_decompressed_bytes;

                        result =
                                inflate(&pvar->ssh_state.decompress_stream, Z_SYNC_FLUSH);
                        cur_decompressed_bytes =
                                pvar->ssh_state.decompress_stream.next_out -
                                pvar->ssh_state.postdecompress_inbuf;

                        switch (result) {
                        case Z_OK:
                                break;
                        case Z_BUF_ERROR:
                                pvar->ssh_state.payloadlen = cur_decompressed_bytes;
                                return cur_decompressed_bytes;
                        default:
                                notify_fatal_error(pvar,
                                                                   "Invalid compressed data in received packet");
                                return -1;
                        }
                }

                return cur_decompressed_bytes;
        }
}

/* For use by the protocol processing code.
   Gets N bytes of uncompressed payload. Returns FALSE if data not available
   and a fatal error has been signaled.
   The data is available in the payload buffer. This buffer address
   can change during a call to grab_payload, so take care!
   The payload pointer is set to point to the first byte of the actual data
   (after the packet type byte).
*/
static BOOL grab_payload(PTInstVar pvar, int num_bytes)
{
        /* Accept maximum of 4MB of payload data */
        int in_buffer = buffer_packet_data(pvar, 4 * 1024 * 1024);

        if (in_buffer < 0) {
                return FALSE;
        } else {
                pvar->ssh_state.payload_grabbed += num_bytes;
                if (pvar->ssh_state.payload_grabbed > in_buffer) {
                        notify_fatal_error(pvar, "Received truncated packet");
                        return FALSE;
                } else {
                        return TRUE;
                }
        }
}

static BOOL grab_payload_limited(PTInstVar pvar, int num_bytes)
{
        int in_buffer;

        pvar->ssh_state.payload_grabbed += num_bytes;
        in_buffer = buffer_packet_data(pvar, pvar->ssh_state.payload_grabbed);

        if (in_buffer < 0) {
                return FALSE;
        } else {
                if (pvar->ssh_state.payload_grabbed > in_buffer) {
                        notify_fatal_error(pvar, "Received truncated packet");
                        return FALSE;
                } else {
                        return TRUE;
                }
        }
}

#define get_payload_uint32(pvar, offset) get_uint32_MSBfirst((pvar)->ssh_state.payload + (offset))
#define get_uint32(buf) get_uint32_MSBfirst((buf))
#define set_uint32(buf, v) set_uint32_MSBfirst((buf), (v))
#define get_mpint_len(pvar, offset) ((get_ushort16_MSBfirst((pvar)->ssh_state.payload + (offset)) + 7) >> 3)
#define get_ushort16(buf) get_ushort16_MSBfirst((buf))

#define do_crc(buf, len) (~(uint32)crc32(0xFFFFFFFF, (buf), (len)))

/* Decrypt the payload, checksum it, eat the padding, get the packet type
   and return it.
   'data' points to the start of the packet --- its length field.
   'len' is the length of the
   payload + padding (+ length of CRC for SSHv1). 'padding' is the length
   of the padding alone. */
static int prep_packet(PTInstVar pvar, char FAR * data, int len,
                                           int padding)
{
        pvar->ssh_state.payload = data + 4;
        pvar->ssh_state.payloadlen = len;

        if (SSHv1(pvar)) {
                if (CRYPT_detect_attack(pvar, pvar->ssh_state.payload, len)) {
                        notify_fatal_error(pvar,
                                                           "'CORE insertion attack' detected.  Aborting connection.");
                        return SSH_MSG_NONE;
                }

                CRYPT_decrypt(pvar, pvar->ssh_state.payload, len);
                /* PKT guarantees that the data is always 4-byte aligned */
                if (do_crc(pvar->ssh_state.payload, len - 4) !=
                        get_uint32_MSBfirst(pvar->ssh_state.payload + len - 4)) {
                        notify_fatal_error(pvar,
                                                           "Detected corrupted data; connection terminating.");
                        return SSH_MSG_NONE;
                }

                pvar->ssh_state.payload += padding;
                pvar->ssh_state.payloadlen -= padding + 4;
        } else {
                int already_decrypted = get_predecryption_amount(pvar);

#if 0
                CRYPT_decrypt(pvar, data + already_decrypted,
                                          len - already_decrypted);
#else
                CRYPT_decrypt(pvar, data + already_decrypted,
                                          (4 + len) - already_decrypted);
#endif

                if (!CRYPT_verify_receiver_MAC
                        (pvar, pvar->ssh_state.receiver_sequence_number, data, len + 4,
                         data + len + 4)) {
                        notify_fatal_error(pvar,
                                                           "Detected corrupted data; connection terminating.");
                        return SSH_MSG_NONE;
                }

                pvar->ssh_state.payload++;
                pvar->ssh_state.payloadlen -= padding + 1;
        }

        pvar->ssh_state.payload_grabbed = 0;

        if (pvar->ssh_state.decompressing) {
                if (pvar->ssh_state.decompress_stream.avail_in != 0) {
                        notify_nonfatal_error(pvar,
                                                                  "Internal error: a packet was not fully decompressed.\n"
                                                                  "This is a bug, please report it.");
                }

                pvar->ssh_state.decompress_stream.next_in =
                        pvar->ssh_state.payload;
                pvar->ssh_state.decompress_stream.avail_in =
                        pvar->ssh_state.payloadlen;
                pvar->ssh_state.decompress_stream.next_out =
                        pvar->ssh_state.postdecompress_inbuf;
                pvar->ssh_state.payloadlen = -1;
        } else {
                pvar->ssh_state.payload++;
        }

        if (!grab_payload_limited(pvar, 1)) {
                return SSH_MSG_NONE;
        }

        pvar->ssh_state.receiver_sequence_number++;

        return pvar->ssh_state.payload[-1];
}

/* Create a packet to be sent. The SSH protocol packet type is in 'type';
   'len' contains the length of the packet payload, in bytes (this
   does not include the space for any of the packet headers or padding,
   or for the packet type byte).
   Returns a pointer to the payload data area, a region of length 'len',
   to be filled by the caller. */
static unsigned char FAR *begin_send_packet(PTInstVar pvar, int type,
                                                                                        int len)
{
        unsigned char FAR *buf;

        pvar->ssh_state.outgoing_packet_len = len + 1;

        if (pvar->ssh_state.compressing) {
                buf_ensure_size(&pvar->ssh_state.precompress_outbuf,
                                                &pvar->ssh_state.precompress_outbuflen, 1 + len);
                buf = pvar->ssh_state.precompress_outbuf;
        } else {
                /* For SSHv2,
                   Encrypted_length is 4(packetlength) + 1(paddinglength) + 1(packettype)
                   + len(payload) + 4(minpadding), rounded up to nearest block_size
                   We only need a reasonable upper bound for the buffer size */
                buf_ensure_size(&pvar->ssh_state.outbuf,
                                                &pvar->ssh_state.outbuflen,
                                                len + 30 + CRYPT_get_sender_MAC_size(pvar) +
                                                CRYPT_get_encryption_block_size(pvar));
                buf = pvar->ssh_state.outbuf + 12;
        }

        buf[0] = (unsigned char) type;
        return buf + 1;
}

#define finish_send_packet(pvar) finish_send_packet_special((pvar), 0)

static BOOL send_packet_blocking(PTInstVar pvar, char FAR * data, int len)
{
        u_long do_block = 0;

        if ((pvar->PWSAAsyncSelect) (pvar->socket, pvar->NotificationWindow,
                                                                 0, 0) == SOCKET_ERROR
                || ioctlsocket(pvar->socket, FIONBIO, &do_block) == SOCKET_ERROR
                || (pvar->Psend) (pvar->socket, data, len, 0) != len
                || (pvar->PWSAAsyncSelect) (pvar->socket, pvar->NotificationWindow,
                                                                        pvar->notification_msg,
                                                                        pvar->notification_events) ==
                SOCKET_ERROR) {
                notify_fatal_error(pvar,
                                                   "A communications error occurred while sending an SSH packet.\n"
                                                   "The connection will close.");
                return FALSE;
        } else {
                return TRUE;
        }
}

/* if skip_compress is true, then the data has already been compressed
   into outbuf + 12 */
static void finish_send_packet_special(PTInstVar pvar, int skip_compress)
{
        int len = pvar->ssh_state.outgoing_packet_len;
        char FAR *data;
        int data_length;

        if (pvar->ssh_state.compressing) {
                if (!skip_compress) {
                        buf_ensure_size(&pvar->ssh_state.outbuf,
                                                        &pvar->ssh_state.outbuflen,
                                                        len + (len >> 6) + 50 +
                                                        CRYPT_get_sender_MAC_size(pvar));
                        pvar->ssh_state.compress_stream.next_in =
                                pvar->ssh_state.precompress_outbuf;
                        pvar->ssh_state.compress_stream.avail_in = len;
                        pvar->ssh_state.compress_stream.next_out =
                                pvar->ssh_state.outbuf + 12;
                        pvar->ssh_state.compress_stream.avail_out =
                                pvar->ssh_state.outbuflen - 12;

                        if (deflate(&pvar->ssh_state.compress_stream, Z_SYNC_FLUSH) !=
                                Z_OK) {
                                notify_fatal_error(pvar,
                                                                   "An error occurred while compressing packet data.\n"
                                                                   "The connection will close.");
                                return;
                        }
                }

                len =
                        pvar->ssh_state.outbuflen - 12 -
                        pvar->ssh_state.compress_stream.avail_out;
        }

        if (SSHv1(pvar)) {
                int padding = 8 - ((len + 4) % 8);

                data = pvar->ssh_state.outbuf + 8 - padding;
                data_length = padding + len + 8;

                set_uint32(data, len + 4);
                if (CRYPT_get_receiver_cipher(pvar) != SSH_CIPHER_NONE) {
                        CRYPT_set_random_data(pvar, data + 4, padding);
                } else {
                        memset(data + 4, 0, padding);
                }
                set_uint32(data + data_length - 4,
                                   do_crc(data + 4, data_length - 8));
                CRYPT_encrypt(pvar, data + 4, data_length - 4);
        } else { //for SSH2(yutaka)
                int block_size = CRYPT_get_encryption_block_size(pvar);
                int encryption_size;
                int padding;
                BOOL ret;

                if (block_size < 8) {
                        block_size = 8;
                }
                encryption_size = ((len + 8) / block_size + 1) * block_size;
                data = pvar->ssh_state.outbuf + 7;
                data_length = encryption_size + CRYPT_get_sender_MAC_size(pvar);

                set_uint32(data, encryption_size - 4);
                padding = encryption_size - len - 5;
                data[4] = (unsigned char) padding;
                CRYPT_set_random_data(pvar, data + 5 + len, padding);
                ret = CRYPT_build_sender_MAC(pvar,
                                                           pvar->ssh_state.sender_sequence_number,
                                                           data, encryption_size,
                                                           data + encryption_size);
                if (ret == FALSE) { // HMAC��������������������������
                        data_length = encryption_size;
                }

                // �p�P�b�g�������������BHMAC���~�������������O�B
                CRYPT_encrypt(pvar, data, encryption_size);
        }

        send_packet_blocking(pvar, data, data_length);

        pvar->ssh_state.sender_sequence_number++;

        // ���M�������L�^ 
        pvar->ssh_heartbeat_tick = time(NULL);
}

static void destroy_packet_buf(PTInstVar pvar)
{
        memset(pvar->ssh_state.outbuf, 0, pvar->ssh_state.outbuflen);
        if (pvar->ssh_state.compressing) {
                memset(pvar->ssh_state.precompress_outbuf, 0,
                           pvar->ssh_state.precompress_outbuflen);
        }
}

/* The handlers are added to the queue for each message. When one of the
   handlers fires, if it returns FALSE, then all handlers in the set are
   removed from their queues. */
static void enque_handlers(PTInstVar pvar, int num_msgs,
                                                   const int FAR * messages,
                                                   const SSHPacketHandler FAR * handlers)
{
        SSHPacketHandlerItem FAR *first_item;
        SSHPacketHandlerItem FAR *last_item = NULL;
        int i;

        for (i = 0; i < num_msgs; i++) {
                SSHPacketHandlerItem FAR *item =
                        (SSHPacketHandlerItem FAR *)
                        malloc(sizeof(SSHPacketHandlerItem));
                SSHPacketHandlerItem FAR *cur_item =
                        pvar->ssh_state.packet_handlers[messages[i]];

                item->handler = handlers[i];

                if (cur_item == NULL) {
                        pvar->ssh_state.packet_handlers[messages[i]] = item;
                        item->next_for_message = item;
                        item->last_for_message = item;
                        item->active_for_message = messages[i];
                } else {
                        item->next_for_message = cur_item;
                        item->last_for_message = cur_item->last_for_message;
                        cur_item->last_for_message->next_for_message = item;
                        cur_item->last_for_message = item;
                        item->active_for_message = -1;
                }

                if (last_item != NULL) {
                        last_item->next_in_set = item;
                } else {
                        first_item = item;
                }
                last_item = item;
        }

        if (last_item != NULL) {
                last_item->next_in_set = first_item;
        }
}

static SSHPacketHandler get_handler(PTInstVar pvar, int message)
{
        SSHPacketHandlerItem FAR *cur_item =
                pvar->ssh_state.packet_handlers[message];

        if (cur_item == NULL) {
                return NULL;
        } else {
                return cur_item->handler;
        }
}

/* Called only by SSH_handle_packet */
static void deque_handlers(PTInstVar pvar, int message)
{
        SSHPacketHandlerItem FAR *cur_item =
                pvar->ssh_state.packet_handlers[message];
        SSHPacketHandlerItem FAR *first_item_in_set = cur_item;

        do {
                SSHPacketHandlerItem FAR *next_in_set = cur_item->next_in_set;

                if (cur_item->active_for_message >= 0) {
                        SSHPacketHandlerItem FAR *replacement =
                                cur_item->next_for_message;

                        if (replacement == cur_item) {
                                replacement = NULL;
                        } else {
                                replacement->active_for_message =
                                        cur_item->active_for_message;
                        }
                        pvar->ssh_state.packet_handlers[cur_item->active_for_message] =
                                replacement;
                }
                cur_item->next_for_message->last_for_message =
                        cur_item->last_for_message;
                cur_item->last_for_message->next_for_message =
                        cur_item->next_for_message;

                free(cur_item);
                cur_item = next_in_set;
        } while (cur_item != first_item_in_set);
}

static void enque_handler(PTInstVar pvar, int message,
                                                  SSHPacketHandler handler)
{
        enque_handlers(pvar, 1, &message, &handler);
}

static void chop_newlines(char FAR * buf)
{
        int len = strlen(buf);

        while (len > 0 && (buf[len - 1] == '\n' || buf[len - 1] == '\r')) {
                buf[len - 1] = 0;
                len--;
        }
}

/********************/
/* Message handlers */
/********************/

static BOOL handle_forwarding_success(PTInstVar pvar)
{
        return FALSE;
}

static BOOL handle_forwarding_failure(PTInstVar pvar)
{
        return FALSE;
}

static void enque_forwarding_request_handlers(PTInstVar pvar)
{
        static const int msgs[] = { SSH_SMSG_SUCCESS, SSH_SMSG_FAILURE };
        static const SSHPacketHandler handlers[]
        = { handle_forwarding_success, handle_forwarding_failure };

        enque_handlers(pvar, 2, msgs, handlers);
}

static BOOL handle_auth_failure(PTInstVar pvar)
{
        notify_verbose_message(pvar, "Authentication failed",
                                                   LOG_LEVEL_VERBOSE);

        AUTH_set_generic_mode(pvar);
        AUTH_advance_to_next_cred(pvar);
        pvar->ssh_state.status_flags &= ~STATUS_DONT_SEND_CREDENTIALS;
        try_send_credentials(pvar);
        return FALSE;
}

static BOOL handle_rsa_auth_refused(PTInstVar pvar)
{
        AUTH_destroy_cur_cred(pvar);
        return handle_auth_failure(pvar);
}

static BOOL handle_TIS_challenge(PTInstVar pvar)
{
        if (grab_payload(pvar, 4)) {
                int len = get_payload_uint32(pvar, 0);

                if (grab_payload(pvar, len)) {
                        notify_verbose_message(pvar, "Received TIS challenge",
                                                                   LOG_LEVEL_VERBOSE);

                        AUTH_set_TIS_mode(pvar, pvar->ssh_state.payload + 4, len);
                        AUTH_advance_to_next_cred(pvar);
                        pvar->ssh_state.status_flags &= ~STATUS_DONT_SEND_CREDENTIALS;
                        try_send_credentials(pvar);
                }
        }
        return FALSE;
}

static BOOL handle_auth_required(PTInstVar pvar)
{
        notify_verbose_message(pvar, "Server requires authentication",
                                                   LOG_LEVEL_VERBOSE);

        pvar->ssh_state.status_flags &= ~STATUS_DONT_SEND_CREDENTIALS;
        try_send_credentials(pvar);
        /* the first AUTH_advance_to_next_cred is issued early by ttxssh.c */

        return FALSE;
}

static BOOL handle_ignore(PTInstVar pvar)
{
        if (grab_payload(pvar, 4)
                && grab_payload(pvar, get_payload_uint32(pvar, 0))) {
                /* ignore it! but it must be decompressed */
        }
        return TRUE;
}

static BOOL handle_debug(PTInstVar pvar)
{
        BOOL always_display;
        char FAR *description;
        int description_len;
        char buf[2048];

        if (SSHv1(pvar)) {
                if (grab_payload(pvar, 4)
                        && grab_payload(pvar, description_len =
                                                        get_payload_uint32(pvar, 0))) {
                        always_display = FALSE;
                        description = pvar->ssh_state.payload + 4;
                        description[description_len] = 0;
                } else {
                        return TRUE;
                }
        } else {
                if (grab_payload(pvar, 5)
                        && grab_payload(pvar,
                                                        (description_len =
                                                         get_payload_uint32(pvar, 1)) + 4)
                        && grab_payload(pvar,
                                                        get_payload_uint32(pvar,
                                                                                           5 + description_len))) {
                        always_display = pvar->ssh_state.payload[0] != 0;
                        description = pvar->ssh_state.payload + 5;
                        description[description_len] = 0;
                } else {
                        return TRUE;
                }
        }

        chop_newlines(description);
        _snprintf(buf, sizeof(buf), "DEBUG message from server: %s",
                          description);
        buf[sizeof(buf) - 1] = 0;
        if (always_display) {
                notify_nonfatal_error(pvar, buf);
        } else {
                notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
        }
        return TRUE;
}

static BOOL handle_disconnect(PTInstVar pvar)
{
        int reason_code;
        char FAR *description;
        int description_len;
        char buf[2048];
        char FAR *explanation = "";

        if (SSHv1(pvar)) {
                if (grab_payload(pvar, 4)
                        && grab_payload(pvar, description_len =
                                                        get_payload_uint32(pvar, 0))) {
                        reason_code = -1;
                        description = pvar->ssh_state.payload + 4;
                        description[description_len] = 0;
                } else {
                        return TRUE;
                }
        } else {
                if (grab_payload(pvar, 8)
                        && grab_payload(pvar,
                                                        (description_len =
                                                         get_payload_uint32(pvar, 4)) + 4)
                        && grab_payload(pvar,
                                                        get_payload_uint32(pvar,
                                                                                           8 + description_len))) {
                        reason_code = get_payload_uint32(pvar, 0);
                        description = pvar->ssh_state.payload + 8;
                        description[description_len] = 0;
                } else {
                        return TRUE;
                }
        }

        chop_newlines(description);
        if (description[0] == 0) {
                description = NULL;
        }

        if (get_handler(pvar, SSH_SMSG_FAILURE) == handle_forwarding_failure) {
                explanation =
                        "\nIt may have disconnected because it was unable to forward a port you requested to be forwarded from the server.\n"
                        "This often happens when someone is already forwarding that port from the server.";
        }

        if (description != NULL) {
                _snprintf(buf, sizeof(buf),
                                  "Server disconnected with message '%s'.%s", description,
                                  explanation);
        } else {
                _snprintf(buf, sizeof(buf),
                                  "Server disconnected (no reason given).%s", explanation);
        }
        buf[sizeof(buf) - 1] = 0;
        notify_fatal_error(pvar, buf);

        return TRUE;
}

static BOOL handle_unimplemented(PTInstVar pvar)
{
        /* Should never receive this since we only send base 2.0 protocol messages */
        grab_payload(pvar, 4);
        return TRUE;
}

static BOOL handle_crypt_success(PTInstVar pvar)
{
        notify_verbose_message(pvar, "Secure mode successfully achieved",
                                                   LOG_LEVEL_VERBOSE);
        return FALSE;
}

static BOOL handle_noauth_success(PTInstVar pvar)
{
        notify_verbose_message(pvar, "Server does not require authentication",
                                                   LOG_LEVEL_VERBOSE);
        prep_compression(pvar);
        return FALSE;
}

static BOOL handle_auth_success(PTInstVar pvar)
{
        notify_verbose_message(pvar, "Authentication accepted",
                                                   LOG_LEVEL_VERBOSE);
        prep_compression(pvar);

        // �n�[�g�r�[�g�E�X���b�h���J�n (2004.12.11 yutaka)
        start_ssh_heartbeat_thread(pvar);

        return FALSE;
}

static BOOL handle_server_public_key(PTInstVar pvar)
{
        int server_key_public_exponent_len;
        int server_key_public_modulus_pos;
        int server_key_public_modulus_len;
        int host_key_bits_pos;
        int host_key_public_exponent_len;
        int host_key_public_modulus_pos;
        int host_key_public_modulus_len;
        int protocol_flags_pos;
        int supported_ciphers;
        char FAR *inmsg;

        if (!grab_payload(pvar, 14))
                return FALSE;
        server_key_public_exponent_len = get_mpint_len(pvar, 12);

        if (!grab_payload(pvar, server_key_public_exponent_len + 2))
                return FALSE;
        server_key_public_modulus_pos = 14 + server_key_public_exponent_len;
        server_key_public_modulus_len =
                get_mpint_len(pvar, server_key_public_modulus_pos);

        if (!grab_payload(pvar, server_key_public_modulus_len + 6))
                return FALSE;
        host_key_bits_pos =
                server_key_public_modulus_pos + 2 + server_key_public_modulus_len;
        host_key_public_exponent_len =
                get_mpint_len(pvar, host_key_bits_pos + 4);

        if (!grab_payload(pvar, host_key_public_exponent_len + 2))
                return FALSE;
        host_key_public_modulus_pos =
                host_key_bits_pos + 6 + host_key_public_exponent_len;
        host_key_public_modulus_len =
                get_mpint_len(pvar, host_key_public_modulus_pos);

        if (!grab_payload(pvar, host_key_public_modulus_len + 12))
                return FALSE;
        protocol_flags_pos =
                host_key_public_modulus_pos + 2 + host_key_public_modulus_len;

        inmsg = pvar->ssh_state.payload;

        CRYPT_set_server_cookie(pvar, inmsg);
        if (!CRYPT_set_server_RSA_key
                (pvar, get_uint32(inmsg + 8), pvar->ssh_state.payload + 12,
                 inmsg + server_key_public_modulus_pos))
                return FALSE;
        if (!CRYPT_set_host_RSA_key
                (pvar, get_uint32(inmsg + host_key_bits_pos),
                 inmsg + host_key_bits_pos + 4,
                 inmsg + host_key_public_modulus_pos))
                return FALSE;
        pvar->ssh_state.server_protocol_flags =
                get_uint32(inmsg + protocol_flags_pos);

        supported_ciphers = get_uint32(inmsg + protocol_flags_pos + 4);
        if (!CRYPT_set_supported_ciphers
                (pvar, supported_ciphers, supported_ciphers))
                return FALSE;
        if (!AUTH_set_supported_auth_types
                (pvar, get_uint32(inmsg + protocol_flags_pos + 8)))
                return FALSE;

        /* this must be the LAST THING in this function, since it can cause
           host_is_OK to be called. */
        HOSTS_check_host_key(pvar, pvar->ssh_state.hostname,
                                                 get_uint32(inmsg + host_key_bits_pos),
                                                 inmsg + host_key_bits_pos + 4,
                                                 inmsg + host_key_public_modulus_pos);

        return FALSE;
}

/*
The ID must have already been found to start with "SSH-". It must
be null-terminated.
*/
static BOOL parse_protocol_ID(PTInstVar pvar, char FAR * ID)
{
        char FAR *str;

        for (str = ID + 4; *str >= '0' && *str <= '9'; str++) {
        }

        if (*str != '.') {
                return FALSE;
        }

        pvar->protocol_major = atoi(ID + 4);
        pvar->protocol_minor = atoi(str + 1);

        // for SSH2(yutaka)
        // 1.99����SSH2�����������s��
        if (pvar->protocol_major == 1 && pvar->protocol_minor == 99) {
                // ���[�U�� SSH2 ���I������������������
                if (pvar->settings.ssh_protocol_version == 2) {
                        pvar->protocol_major = 2;
                        pvar->protocol_minor = 0;
                }

        }

        for (str = str + 1; *str >= '0' && *str <= '9'; str++) {
        }

        return *str == '-';
}

/*
On entry, the pvar->protocol_xxx fields hold the server's advertised
protocol number. We replace the fields with the protocol number we will
actually use, or return FALSE if there is no usable protocol version.
*/
static BOOL negotiate_protocol(PTInstVar pvar)
{
        switch (pvar->protocol_major) {
        case 1:
                if (pvar->protocol_minor > 5) {
                        pvar->protocol_minor = 5;
                }

                return TRUE;

        // for SSH2(yutaka)
        case 2:
                return TRUE;                    // SSH2 support

        default:
                return FALSE;
        }
}

static void init_protocol(PTInstVar pvar)
{
        CRYPT_initialize_random_numbers(pvar);
        HOSTS_prefetch_host_key(pvar, pvar->ssh_state.hostname);
        /* while we wait for a response from the server... */

        if (SSHv1(pvar)) {
                enque_handler(pvar, SSH_MSG_DISCONNECT, handle_disconnect);
                enque_handler(pvar, SSH_MSG_IGNORE, handle_ignore);
                enque_handler(pvar, SSH_MSG_DEBUG, handle_debug);
                enque_handler(pvar, SSH_SMSG_PUBLIC_KEY, handle_server_public_key);

        } else {  // for SSH2(yutaka)
                enque_handler(pvar, SSH2_MSG_DISCONNECT, handle_disconnect);
                enque_handler(pvar, SSH2_MSG_IGNORE, handle_ignore);
                enque_handler(pvar, SSH2_MSG_DEBUG, handle_debug);
                enque_handler(pvar, SSH2_MSG_KEXINIT, handle_SSH2_kexinit);
                enque_handler(pvar, SSH2_MSG_KEXDH_INIT, handle_unimplemented);
                enque_handler(pvar, SSH2_MSG_KEXDH_REPLY, handle_SSH2_dh_common_reply); 
                enque_handler(pvar, SSH2_MSG_KEX_DH_GEX_REPLY, handle_SSH2_dh_gex_reply); 
                enque_handler(pvar, SSH2_MSG_NEWKEYS, handle_SSH2_newkeys);
                enque_handler(pvar, SSH2_MSG_SERVICE_ACCEPT, handle_SSH2_authrequest);
                enque_handler(pvar, SSH2_MSG_USERAUTH_SUCCESS, handle_SSH2_userauth_success);
                enque_handler(pvar, SSH2_MSG_USERAUTH_FAILURE, handle_SSH2_userauth_failure);
                enque_handler(pvar, SSH2_MSG_USERAUTH_BANNER, handle_SSH2_userauth_banner);
                enque_handler(pvar, SSH2_MSG_USERAUTH_INFO_REQUEST, handle_SSH2_userauth_inforeq);

                enque_handler(pvar, SSH2_MSG_UNIMPLEMENTED, handle_unimplemented);

                // ���[�U�F�������f�B�X�p�b�`���[�`��
                enque_handler(pvar, SSH2_MSG_CHANNEL_CLOSE, handle_SSH2_channel_close);
                enque_handler(pvar, SSH2_MSG_CHANNEL_DATA, handle_SSH2_channel_data);
                enque_handler(pvar, SSH2_MSG_CHANNEL_EOF, handle_SSH2_channel_eof);
//              enque_handler(pvar, SSH2_MSG_CHANNEL_EXTENDED_DATA, handle_SSH2_channel_extended_data);
//              enque_handler(pvar, SSH2_MSG_CHANNEL_OPEN, handle_unimplemented);
                enque_handler(pvar, SSH2_MSG_CHANNEL_OPEN_CONFIRMATION, handle_SSH2_open_confirm);
//              enque_handler(pvar, SSH2_MSG_CHANNEL_OPEN_FAILURE, handle_unimplemented);
                enque_handler(pvar, SSH2_MSG_CHANNEL_REQUEST, handle_SSH2_channel_request);
                enque_handler(pvar, SSH2_MSG_CHANNEL_WINDOW_ADJUST, handle_SSH2_window_adjust);
                enque_handler(pvar, SSH2_MSG_CHANNEL_SUCCESS, handle_SSH2_channel_success);
//              enque_handler(pvar, SSH2_MSG_GLOBAL_REQUEST, handle_unimplemented);
//              enque_handler(pvar, SSH2_MSG_REQUEST_FAILURE, handle_unimplemented);
                enque_handler(pvar, SSH2_MSG_REQUEST_SUCCESS, handle_SSH2_request_success);

        }
}

BOOL SSH_handle_server_ID(PTInstVar pvar, char FAR * ID, int ID_len)
{
        static const char prefix[] = "Received server prologue string: ";

        // initialize SSH2 memory dump (2005.3.7 yutaka)
        init_memdump();
        push_memdump("pure server ID", "�v���g�R�����������������J�n", ID, ID_len);

        if (ID_len <= 0) {
                return FALSE;
        } else {
                char FAR *buf = (char FAR *) malloc(ID_len + NUM_ELEM(prefix));

                strcpy(buf, prefix);
                strncpy(buf + NUM_ELEM(prefix) - 1, ID, ID_len);
                buf[NUM_ELEM(prefix) + ID_len - 1] = 0;
                chop_newlines(buf);

                notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);

                free(buf);


                // ���������R�s�[������ (2005.3.9 yutaka)
#if 0
                // for calculate SSH2 hash
                // �T�[�o�o�[�W�����������i���s���������������j
                if (ID_len >= sizeof(pvar->server_version_string)) 
                        return FALSE;
                strncpy(pvar->server_version_string, ID, ID_len);
#endif


                if (ID[ID_len - 1] != '\n') {
                        pvar->ssh_state.status_flags |= STATUS_IN_PARTIAL_ID_STRING;
                        return FALSE;
                } else
                        if ((pvar->ssh_state.
                                 status_flags & STATUS_IN_PARTIAL_ID_STRING) != 0) {
                        pvar->ssh_state.status_flags &= ~STATUS_IN_PARTIAL_ID_STRING;
                        return FALSE;
                } else if (strncmp(ID, "SSH-", 4) != 0) {
                        return FALSE;
                } else {
                        ID[ID_len - 1] = 0;

                        if (ID_len > 1 && ID[ID_len - 2] == '\r') {
                                ID[ID_len - 2] = 0;
                        }

                        pvar->ssh_state.server_ID = _strdup(ID);

                        if (!parse_protocol_ID(pvar, ID) || !negotiate_protocol(pvar)) {
                                notify_fatal_error(pvar,
                                                                   "This program does not understand the server's version of the protocol.");
                        } else {
                                char TTSSH_ID[1024];
                                int TTSSH_ID_len;
                                int a, b, c, d;

                                // �������g���o�[�W�������������� (2005.3.3 yutaka)
                                get_file_version("ttxssh.dll", &a, &b, &c, &d);

                                _snprintf(TTSSH_ID, sizeof(TTSSH_ID),
                                                  "SSH-%d.%d-TTSSH/%d.%d Win32\n",
                                                  pvar->protocol_major, pvar->protocol_minor, a, b);
                                TTSSH_ID_len = strlen(TTSSH_ID);

                                // for SSH2(yutaka)
                                // �N���C�A���g�o�[�W�����������i���s���������������j
                                strncpy(pvar->client_version_string, TTSSH_ID, TTSSH_ID_len);

                                // �T�[�o�o�[�W�����������i���s���������������j(2005.3.9 yutaka)
                                _snprintf(pvar->server_version_string, sizeof(pvar->server_version_string), "%s", pvar->ssh_state.server_ID);

                                if ((pvar->Psend) (pvar->socket, TTSSH_ID, TTSSH_ID_len,
                                                                   0) != TTSSH_ID_len) {
                                        notify_fatal_error(pvar,
                                                                           "An error occurred while sending the SSH ID string.\n"
                                                                           "The connection will close.");
                                } else {
                                        // ���s�R�[�h������ (2004.8.4 yutaka)
                                        pvar->client_version_string[--TTSSH_ID_len] = 0;

                                        push_memdump("server ID", NULL, pvar->server_version_string, strlen(pvar->server_version_string));
                                        push_memdump("client ID", NULL, pvar->client_version_string, strlen(pvar->client_version_string));

                                        // SSH�n���h�����o�^���s��
                                        init_protocol(pvar);

                                        SSH2_dispatch_init(1);
                                        SSH2_dispatch_add_message(SSH2_MSG_KEXINIT);
                                        SSH2_dispatch_add_message(SSH2_MSG_IGNORE); // XXX: Tru64 UNIX workaround   (2005.3.3 yutaka)
                                }
                        }

                        return TRUE;
                }
        }
}

static BOOL handle_exit(PTInstVar pvar)
{
        if (grab_payload(pvar, 4)) {
                begin_send_packet(pvar, SSH_CMSG_EXIT_CONFIRMATION, 0);
                finish_send_packet(pvar);
                notify_closed_connection(pvar);
        }
        return TRUE;
}

static BOOL handle_data(PTInstVar pvar)
{
        if (grab_payload_limited(pvar, 4)) {
                pvar->ssh_state.payload_datalen = get_payload_uint32(pvar, 0);
                pvar->ssh_state.payload_datastart = 4;
        }
        return TRUE;
}

static BOOL handle_channel_open(PTInstVar pvar)
{
        int host_len;
        int originator_len;

        if ((pvar->ssh_state.
                 server_protocol_flags & SSH_PROTOFLAG_HOST_IN_FWD_OPEN) != 0) {
                if (grab_payload(pvar, 8)
                        && grab_payload(pvar,
                                                        8 + (host_len = get_payload_uint32(pvar, 4)))
                        && grab_payload(pvar, originator_len =
                                                        get_payload_uint32(pvar, host_len + 12))) {
                        int local_port = get_payload_uint32(pvar, 8 + host_len);

                        pvar->ssh_state.payload[8 + host_len] = 0;
                        FWD_open(pvar, get_payload_uint32(pvar, 0),
                                         pvar->ssh_state.payload + 8, local_port,
                                         pvar->ssh_state.payload + 16 + host_len,
                                         originator_len);
                }
        } else {
                if (grab_payload(pvar, 8)
                        && grab_payload(pvar,
                                                        4 + (host_len =
                                                                 get_payload_uint32(pvar, 4)))) {
                        int local_port = get_payload_uint32(pvar, 8 + host_len);

                        pvar->ssh_state.payload[8 + host_len] = 0;
                        FWD_open(pvar, get_payload_uint32(pvar, 0),
                                         pvar->ssh_state.payload + 8, local_port, NULL, 0);
                }
        }

        return TRUE;
}

static BOOL handle_X11_channel_open(PTInstVar pvar)
{
        int originator_len;

        if ((pvar->ssh_state.
                 server_protocol_flags & SSH_PROTOFLAG_HOST_IN_FWD_OPEN) != 0) {
                if (grab_payload(pvar, 8)
                        && grab_payload(pvar, originator_len =
                                                        get_payload_uint32(pvar, 4))) {
                        FWD_X11_open(pvar, get_payload_uint32(pvar, 0),
                                                 pvar->ssh_state.payload + 8, originator_len);
                }
        } else {
                if (grab_payload(pvar, 4)) {
                        FWD_X11_open(pvar, get_payload_uint32(pvar, 0), NULL, 0);
                }
        }

        return TRUE;
}

static BOOL handle_channel_open_confirmation(PTInstVar pvar)
{
        if (grab_payload(pvar, 8)) {
                FWD_confirmed_open(pvar, get_payload_uint32(pvar, 0),
                                                   get_payload_uint32(pvar, 4));
        }
        return FALSE;
}

static BOOL handle_channel_open_failure(PTInstVar pvar)
{
        if (grab_payload(pvar, 4)) {
                FWD_failed_open(pvar, get_payload_uint32(pvar, 0));
        }
        return FALSE;
}

static BOOL handle_channel_data(PTInstVar pvar)
{
        int len;

        if (grab_payload(pvar, 8)
                && grab_payload(pvar, len = get_payload_uint32(pvar, 4))) {
                FWD_received_data(pvar, get_payload_uint32(pvar, 0),
                                                  pvar->ssh_state.payload + 8, len);
        }
        return TRUE;
}

static BOOL handle_channel_input_eof(PTInstVar pvar)
{
        if (grab_payload(pvar, 4)) {
                FWD_channel_input_eof(pvar, get_payload_uint32(pvar, 0));
        }
        return TRUE;
}

static BOOL handle_channel_output_eof(PTInstVar pvar)
{
        if (grab_payload(pvar, 4)) {
                FWD_channel_output_eof(pvar, get_payload_uint32(pvar, 0));
        }
        return TRUE;
}


// �n���h�����O�������b�Z�[�W����������

#define HANDLE_MESSAGE_MAX 30
static unsigned char handle_messages[HANDLE_MESSAGE_MAX];
static int handle_message_count = 0;
static int handle_message_stage = 0;

void SSH2_dispatch_init(int stage)
{
        handle_message_count = 0;
        handle_message_stage = stage;
}

int SSH2_dispatch_enabled_check(unsigned char message)
{
        int i;

        for (i = 0 ; i < handle_message_count ; i++) {
                if (handle_messages[i] == message)
                        return 1;
        }
        return 0;
}

void SSH2_dispatch_add_message(unsigned char message)
{

        if (handle_message_count >= HANDLE_MESSAGE_MAX) {
                // TODO: error check
                return;
        }

        handle_messages[handle_message_count++] = message;
}

void SSH2_dispatch_add_range_message(unsigned char begin, unsigned char end)
{
        unsigned char c;

        for (c = begin ; c <= end ; c++) {
                SSH2_dispatch_add_message(c);
        }
}


void SSH_handle_packet(PTInstVar pvar, char FAR * data, int len,
                                           int padding)
{
        unsigned char message = prep_packet(pvar, data, len, padding);

        
#ifdef SSH2_DEBUG
        // for SSH2(yutaka)
        if (SSHv2(pvar)) {
                if (pvar->key_done) {
                        message = message;
                }

                if (pvar->userauth_success) {
                        message = message;
                }

                if (pvar->rekeying) {
                        message = message;
                }
        }
#endif

        // SSH�����b�Z�[�W�^�C�v���`�F�b�N
        if (message != SSH_MSG_NONE) {
                // ���b�Z�[�W�^�C�v���������n���h�����N��
                SSHPacketHandler handler = get_handler(pvar, message);

                // for SSH2(yutaka)
                if (SSHv2(pvar)) {
                        // �z���O�����b�Z�[�W�^�C�v�������������A�{�[�g�������B
                        if (!SSH2_dispatch_enabled_check(message) || handler == NULL) {
                                char buf[1024];

                                _snprintf(buf, sizeof(buf),
                                        "Unexpected SSH2 message(%d) on current stage(%d)", message, handle_message_stage);
                                notify_fatal_error(pvar, buf);
                                // abort
                        }
                }

                if (handler == NULL) {
                        if (SSHv1(pvar)) {
                                char buf[1024];

                                _snprintf(buf, sizeof(buf),
                                                  "Unexpected packet type received: %d", message);
                                buf[sizeof(buf) - 1] = 0;
                                notify_fatal_error(pvar, buf);
                        } else {
                                unsigned char FAR *outmsg =
                                        begin_send_packet(pvar, SSH2_MSG_UNIMPLEMENTED, 4);

                                set_uint32(outmsg,
                                                   pvar->ssh_state.receiver_sequence_number - 1);
                                finish_send_packet(pvar);
                                /* XXX need to decompress incoming packet, but how? */
                        }
                } else {
                        if (!handler(pvar)) {
                                deque_handlers(pvar, message);
                        }
                }
        }
}

static BOOL handle_pty_success(PTInstVar pvar)
{
        FWD_enter_interactive_mode(pvar);
        enque_handler(pvar, SSH_SMSG_EXITSTATUS, handle_exit);
        enque_handler(pvar, SSH_SMSG_STDOUT_DATA, handle_data);
        enque_handler(pvar, SSH_SMSG_STDERR_DATA, handle_data);
        enque_handler(pvar, SSH_MSG_CHANNEL_DATA, handle_channel_data);
        enque_handler(pvar, SSH_MSG_CHANNEL_INPUT_EOF,
                                  handle_channel_input_eof);
        enque_handler(pvar, SSH_MSG_CHANNEL_OUTPUT_CLOSED,
                                  handle_channel_output_eof);
        enque_handler(pvar, SSH_MSG_PORT_OPEN, handle_channel_open);
        enque_handler(pvar, SSH_SMSG_X11_OPEN, handle_X11_channel_open);
        return FALSE;
}

static BOOL handle_pty_failure(PTInstVar pvar)
{
        notify_nonfatal_error(pvar,
                                                  "The server cannot allocate a pseudo-terminal. "
                                                  "You may encounter some problems with the terminal.");
        return handle_pty_success(pvar);
}

static void prep_pty(PTInstVar pvar)
{
        int len = strlen(pvar->ts->TermType);
        unsigned char FAR *outmsg =
                begin_send_packet(pvar, SSH_CMSG_REQUEST_PTY,
                                                  4 + len + 16 + sizeof(ssh_ttymodes));
        static const int msgs[] = { SSH_SMSG_SUCCESS, SSH_SMSG_FAILURE };
        static const SSHPacketHandler handlers[]
        = { handle_pty_success, handle_pty_failure };

        set_uint32(outmsg, len);
        memcpy(outmsg + 4, pvar->ts->TermType, len);
        set_uint32(outmsg + 4 + len, pvar->ssh_state.win_rows);
        set_uint32(outmsg + 4 + len + 4, pvar->ssh_state.win_cols);
        set_uint32(outmsg + 4 + len + 8, 0);
        set_uint32(outmsg + 4 + len + 12, 0);
        memcpy(outmsg + 4 + len + 16, ssh_ttymodes, sizeof(ssh_ttymodes));
        finish_send_packet(pvar);

        enque_handlers(pvar, 2, msgs, handlers);

        begin_send_packet(pvar, SSH_CMSG_EXEC_SHELL, 0);
        finish_send_packet(pvar);
}

static void prep_forwarding(PTInstVar pvar)
{
        FWD_prep_forwarding(pvar);
        prep_pty(pvar);
}

static void enable_compression(PTInstVar pvar)
{
        pvar->ssh_state.compress_stream.zalloc = NULL;
        pvar->ssh_state.compress_stream.zfree = NULL;
        pvar->ssh_state.compress_stream.opaque = NULL;
        if (deflateInit
                (&pvar->ssh_state.compress_stream,
                 pvar->ssh_state.compression_level) != Z_OK) {
                notify_fatal_error(pvar,
                                                   "An error occurred while setting up compression.\n"
                                                   "The connection will close.");
                return;
        } else {
                pvar->ssh_state.compressing = TRUE;
        }

        pvar->ssh_state.decompress_stream.zalloc = NULL;
        pvar->ssh_state.decompress_stream.zfree = NULL;
        pvar->ssh_state.decompress_stream.opaque = NULL;
        if (inflateInit(&pvar->ssh_state.decompress_stream) != Z_OK) {
                deflateEnd(&pvar->ssh_state.compress_stream);
                notify_fatal_error(pvar,
                                                   "An error occurred while setting up compression.\n"
                                                   "The connection will close.");
                return;
        } else {
                pvar->ssh_state.decompressing = TRUE;
                buf_ensure_size(&pvar->ssh_state.postdecompress_inbuf,
                                                &pvar->ssh_state.postdecompress_inbuflen, 1000);
        }
}

static BOOL handle_enable_compression(PTInstVar pvar)
{
        enable_compression(pvar);
        prep_forwarding(pvar);
        return FALSE;
}

static BOOL handle_disable_compression(PTInstVar pvar)
{
        prep_forwarding(pvar);
        return FALSE;
}

static void prep_compression(PTInstVar pvar)
{
        if (pvar->session_settings.CompressionLevel > 0) {
                static const int msgs[] = { SSH_SMSG_SUCCESS, SSH_SMSG_FAILURE };
                static const SSHPacketHandler handlers[]
                = { handle_enable_compression, handle_disable_compression };

                unsigned char FAR *outmsg =
                        begin_send_packet(pvar, SSH_CMSG_REQUEST_COMPRESSION, 4);

                set_uint32(outmsg, pvar->session_settings.CompressionLevel);
                finish_send_packet(pvar);

                pvar->ssh_state.compression_level =
                        pvar->session_settings.CompressionLevel;

                enque_handlers(pvar, 2, msgs, handlers);
        } else {
                prep_forwarding(pvar);
        }
}

static void enque_simple_auth_handlers(PTInstVar pvar)
{
        static const int msgs[] = { SSH_SMSG_SUCCESS, SSH_SMSG_FAILURE };
        static const SSHPacketHandler handlers[]
        = { handle_auth_success, handle_auth_failure };

        enque_handlers(pvar, 2, msgs, handlers);
}

static BOOL handle_rsa_challenge(PTInstVar pvar)
{
        int challenge_bytes;

        if (!grab_payload(pvar, 2)) {
                return FALSE;
        }

        challenge_bytes = get_mpint_len(pvar, 0);

        if (grab_payload(pvar, challenge_bytes)) {
                unsigned char FAR *outmsg =
                        begin_send_packet(pvar, SSH_CMSG_AUTH_RSA_RESPONSE, 16);

                if (CRYPT_generate_RSA_challenge_response
                        (pvar, pvar->ssh_state.payload + 2, challenge_bytes, outmsg)) {
                        AUTH_destroy_cur_cred(pvar);
                        finish_send_packet(pvar);

                        enque_simple_auth_handlers(pvar);
                } else {
                        notify_fatal_error(pvar,
                                                           "An error occurred while decrypting the RSA challenge.\n"
                                                           "Perhaps the key file is corrupted.");
                }
        }

        return FALSE;
}

#define OBFUSCATING_ROUND_TO 32

static int obfuscating_round_up(PTInstVar pvar, int size)
{
        return (size + OBFUSCATING_ROUND_TO - 1) & ~(OBFUSCATING_ROUND_TO - 1);
}

static void try_send_credentials(PTInstVar pvar)
{
        if ((pvar->ssh_state.status_flags & STATUS_DONT_SEND_CREDENTIALS) == 0) {
                AUTHCred FAR *cred = AUTH_get_cur_cred(pvar);
                static const int RSA_msgs[] =
                        { SSH_SMSG_AUTH_RSA_CHALLENGE, SSH_SMSG_FAILURE };
                static const SSHPacketHandler RSA_handlers[]
                = { handle_rsa_challenge, handle_rsa_auth_refused };
                static const int TIS_msgs[] =
                        { SSH_SMSG_AUTH_TIS_CHALLENGE, SSH_SMSG_FAILURE };
                static const SSHPacketHandler TIS_handlers[]
                = { handle_TIS_challenge, handle_auth_failure };

                // SSH2���������������������X�L�b�v
                if (SSHv2(pvar)) 
                        goto skip_ssh2;

                switch (cred->method) {
                case SSH_AUTH_NONE:
                        return;
                case SSH_AUTH_PASSWORD:{
                                int len = strlen(cred->password);
                                // Round up password length to discourage traffic analysis
                                int obfuscated_len = obfuscating_round_up(pvar, len);
                                unsigned char FAR *outmsg =
                                        begin_send_packet(pvar, SSH_CMSG_AUTH_PASSWORD,
                                                                          4 + obfuscated_len);

                                notify_verbose_message(pvar,
                                                                           "Trying PASSWORD authentication...",
                                                                           LOG_LEVEL_VERBOSE);

                                set_uint32(outmsg, obfuscated_len);
                                memcpy(outmsg + 4, cred->password, len);
                                memset(outmsg + 4 + len, 0, obfuscated_len - len);
                                AUTH_destroy_cur_cred(pvar);
                                enque_simple_auth_handlers(pvar);
                                break;
                        }
                case SSH_AUTH_RHOSTS:{
                                int len = strlen(cred->rhosts_client_user);
                                unsigned char FAR *outmsg =
                                        begin_send_packet(pvar, SSH_CMSG_AUTH_RHOSTS, 4 + len);

                                notify_verbose_message(pvar,
                                                                           "Trying RHOSTS authentication...",
                                                                           LOG_LEVEL_VERBOSE);

                                set_uint32(outmsg, len);
                                memcpy(outmsg + 4, cred->rhosts_client_user, len);
                                AUTH_destroy_cur_cred(pvar);
                                enque_simple_auth_handlers(pvar);
                                break;
                        }
                case SSH_AUTH_RSA:{
                                int len = BN_num_bytes(cred->key_pair->RSA_key->n);
                                unsigned char FAR *outmsg =
                                        begin_send_packet(pvar, SSH_CMSG_AUTH_RSA, 2 + len);

                                notify_verbose_message(pvar,
                                                                           "Trying RSA authentication...",
                                                                           LOG_LEVEL_VERBOSE);

                                set_ushort16_MSBfirst(outmsg, len * 8);
                                BN_bn2bin(cred->key_pair->RSA_key->n, outmsg + 2);
                                /* don't destroy the current credentials yet */
                                enque_handlers(pvar, 2, RSA_msgs, RSA_handlers);
                                break;
                        }
                case SSH_AUTH_RHOSTS_RSA:{
                                int mod_len = BN_num_bytes(cred->key_pair->RSA_key->n);
                                int name_len = strlen(cred->rhosts_client_user);
                                int exp_len = BN_num_bytes(cred->key_pair->RSA_key->e);
                                int index;
                                unsigned char FAR *outmsg =
                                        begin_send_packet(pvar, SSH_CMSG_AUTH_RHOSTS_RSA,
                                                                          12 + mod_len + name_len + exp_len);

                                notify_verbose_message(pvar,
                                                                           "Trying RHOSTS+RSA authentication...",
                                                                           LOG_LEVEL_VERBOSE);

                                set_uint32(outmsg, name_len);
                                memcpy(outmsg + 4, cred->rhosts_client_user, name_len);
                                index = 4 + name_len;

                                set_uint32(outmsg + index, 8 * mod_len);
                                set_ushort16_MSBfirst(outmsg + index + 4, 8 * exp_len);
                                BN_bn2bin(cred->key_pair->RSA_key->e, outmsg + index + 6);
                                index += 6 + exp_len;

                                set_ushort16_MSBfirst(outmsg + index, 8 * mod_len);
                                BN_bn2bin(cred->key_pair->RSA_key->n, outmsg + index + 2);
                                /* don't destroy the current credentials yet */
                                enque_handlers(pvar, 2, RSA_msgs, RSA_handlers);
                                break;
                        }
                case SSH_AUTH_TIS:{
                                if (cred->password == NULL) {
                                        unsigned char FAR *outmsg =
                                                begin_send_packet(pvar, SSH_CMSG_AUTH_TIS, 0);

                                        notify_verbose_message(pvar,
                                                                                "Trying TIS authentication...",
                                                                                LOG_LEVEL_VERBOSE);
                                        enque_handlers(pvar, 2, TIS_msgs, TIS_handlers);
                                } else {
                                        int len = strlen(cred->password);
                                        int obfuscated_len = obfuscating_round_up(pvar, len);
                                        unsigned char FAR *outmsg =
                                                begin_send_packet(pvar, SSH_CMSG_AUTH_TIS_RESPONSE,
                                                                                4 + obfuscated_len);

                                        notify_verbose_message(pvar, "Sending TIS response",
                                                                                LOG_LEVEL_VERBOSE);

                                        set_uint32(outmsg, obfuscated_len);
                                        memcpy(outmsg + 4, cred->password, len);
                                        memset(outmsg + 4 + len, 0, obfuscated_len - len);
                                        enque_simple_auth_handlers(pvar);
                                }

                                AUTH_destroy_cur_cred(pvar);
                                break;
                        }
                default:
                        notify_fatal_error(pvar,
                                                           "Internal error: unsupported authentication method");
                        return;
                }

                finish_send_packet(pvar);

skip_ssh2:;
                destroy_packet_buf(pvar);

                pvar->ssh_state.status_flags |= STATUS_DONT_SEND_CREDENTIALS;
        }
}

static void try_send_user_name(PTInstVar pvar)
{
        if ((pvar->ssh_state.status_flags & STATUS_DONT_SEND_USER_NAME) == 0) {
                char FAR *username = AUTH_get_user_name(pvar);

                if (username != NULL) {
                        int len = strlen(username);
                        int obfuscated_len = obfuscating_round_up(pvar, len);
                        unsigned char FAR *outmsg =
                                begin_send_packet(pvar, SSH_CMSG_USER, 4 + obfuscated_len);
                        char buf[1024] = "Sending user name: ";
                        static const int msgs[] =
                                { SSH_SMSG_SUCCESS, SSH_SMSG_FAILURE };
                        static const SSHPacketHandler handlers[]
                        = { handle_noauth_success, handle_auth_required };

                        set_uint32(outmsg, obfuscated_len);
                        memcpy(outmsg + 4, username, len);
                        memset(outmsg + 4 + len, 0, obfuscated_len - len);
                        finish_send_packet(pvar);

                        pvar->ssh_state.status_flags |= STATUS_DONT_SEND_USER_NAME;

                        strncpy(buf + strlen(buf), username,
                                        sizeof(buf) - strlen(buf) - 2);
                        buf[sizeof(buf) - 1] = 0;
                        notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);

                        enque_handlers(pvar, 2, msgs, handlers);
                }
        }
}

static void send_session_key(PTInstVar pvar)
{
        int encrypted_session_key_len;
        unsigned char FAR *outmsg;

        if (SSHv1(pvar)) {
                encrypted_session_key_len =
                        CRYPT_get_encrypted_session_key_len(pvar);
        }

        if (!CRYPT_choose_ciphers(pvar))
                return;

        if (SSHv1(pvar)) {
                outmsg =
                        begin_send_packet(pvar, SSH_CMSG_SESSION_KEY,
                                                          15 + encrypted_session_key_len);
                outmsg[0] = (unsigned char) CRYPT_get_sender_cipher(pvar);
                memcpy(outmsg + 1, CRYPT_get_server_cookie(pvar), 8);   /* antispoofing cookie */
                outmsg[9] = (unsigned char) (encrypted_session_key_len >> 5);
                outmsg[10] = (unsigned char) (encrypted_session_key_len << 3);
                if (!CRYPT_choose_session_key(pvar, outmsg + 11))
                        return;
                set_uint32(outmsg + 11 + encrypted_session_key_len,
                                   SSH_PROTOFLAG_SCREEN_NUMBER |
                                   SSH_PROTOFLAG_HOST_IN_FWD_OPEN);
                finish_send_packet(pvar);
        }

        if (!CRYPT_start_encryption(pvar, 1, 1))
                return;
        notify_established_secure_connection(pvar);

        if (SSHv1(pvar)) {
                enque_handler(pvar, SSH_SMSG_SUCCESS, handle_crypt_success);
        }

        pvar->ssh_state.status_flags &= ~STATUS_DONT_SEND_USER_NAME;

        if (SSHv1(pvar)) {
                try_send_user_name(pvar);
        }
}

/*************************
   END of message handlers
   ************************/

void SSH_init(PTInstVar pvar)
{
        int i;

        buf_create(&pvar->ssh_state.outbuf, &pvar->ssh_state.outbuflen);
        buf_create(&pvar->ssh_state.precompress_outbuf,
                           &pvar->ssh_state.precompress_outbuflen);
        buf_create(&pvar->ssh_state.postdecompress_inbuf,
                           &pvar->ssh_state.postdecompress_inbuflen);
        pvar->ssh_state.payload = NULL;
        pvar->ssh_state.compressing = FALSE;
        pvar->ssh_state.decompressing = FALSE;
        pvar->ssh_state.status_flags =
                STATUS_DONT_SEND_USER_NAME | STATUS_DONT_SEND_CREDENTIALS;
        pvar->ssh_state.payload_datalen = 0;
        pvar->ssh_state.hostname = NULL;
        pvar->ssh_state.server_ID = NULL;
        pvar->ssh_state.receiver_sequence_number = 0;
        pvar->ssh_state.sender_sequence_number = 0;
        for (i = 0; i < NUM_ELEM(pvar->ssh_state.packet_handlers); i++) {
                pvar->ssh_state.packet_handlers[i] = NULL;
        }

        // for SSH2(yutaka)
        memset(pvar->ssh2_keys, 0, sizeof(pvar->ssh2_keys));
        pvar->userauth_success = 0;
        pvar->session_nego_status = 0;
        pvar->settings.ssh_protocol_version = 2;  // SSH2(default)
        pvar->rekeying = 0;
        pvar->key_done = 0;
        pvar->ssh2_autologin = 0;  // autologin disabled(default)
        pvar->userauth_retry_count = 0;

}

void SSH_open(PTInstVar pvar)
{
        pvar->ssh_state.hostname = _strdup(pvar->ts->HostName);
        pvar->ssh_state.win_cols = pvar->ts->TerminalWidth;
        pvar->ssh_state.win_rows = pvar->ts->TerminalHeight;
}

void SSH_notify_disconnecting(PTInstVar pvar, char FAR * reason)
{
        if (SSHv1(pvar)) {
                int len = reason == NULL ? 0 : strlen(reason);
                unsigned char FAR *outmsg =
                        begin_send_packet(pvar, SSH_MSG_DISCONNECT, len + 4);

                set_uint32(outmsg, len);
                if (reason != NULL) {
                        memcpy(outmsg + 4, reason, len);
                }
                finish_send_packet(pvar);

        } else { // for SSH2(yutaka)
                buffer_t *msg;
                unsigned char *outmsg;
                int len;
                Channel_t *c;

                c = ssh2_channel_lookup(pvar->shell_id);
                if (c == NULL)
                        return;

                // SSH2 server��channel close���`����
                msg = buffer_init();
                if (msg == NULL) {
                        // TODO: error check
                        return;
                }
                buffer_put_int(msg, c->remote_id);  

                len = buffer_len(msg);
                outmsg = begin_send_packet(pvar, SSH2_MSG_CHANNEL_CLOSE, len);
                memcpy(outmsg, buffer_ptr(msg), len);
                finish_send_packet(pvar);
                buffer_free(msg);

        }

}

void SSH_notify_host_OK(PTInstVar pvar)
{
        if ((pvar->ssh_state.status_flags & STATUS_HOST_OK) == 0) {
                pvar->ssh_state.status_flags |= STATUS_HOST_OK;
                send_session_key(pvar);
        }
}

void SSH_notify_win_size(PTInstVar pvar, int cols, int rows)
{
        pvar->ssh_state.win_cols = cols;
        pvar->ssh_state.win_rows = rows;

        if (SSHv1(pvar)) {
                if (get_handler(pvar, SSH_SMSG_STDOUT_DATA) == handle_data) {
                        unsigned char FAR *outmsg =
                                begin_send_packet(pvar, SSH_CMSG_WINDOW_SIZE, 16);

                        set_uint32(outmsg, rows);
                        set_uint32(outmsg + 4, cols);
                        set_uint32(outmsg + 8, 0);
                        set_uint32(outmsg + 12, 0);
                        finish_send_packet(pvar);
                }

        } else if (SSHv2(pvar)) { // �^�[�~�i���T�C�Y���X���m������ (2005.1.4 yutaka)
                                      // SSH2�����������`�F�b�N���s���B(2005.1.5 yutaka)
                buffer_t *msg;
                char *s;
                unsigned char *outmsg;
                int len;
                Channel_t *c;

                c = ssh2_channel_lookup(pvar->shell_id);
                if (c == NULL)
                        return;

                msg = buffer_init();
                if (msg == NULL) {
                        // TODO: error check
                        return;
                }
                buffer_put_int(msg, c->remote_id);  
                s = "window-change";  
                buffer_put_string(msg, s, strlen(s));  
                buffer_put_char(msg, 0);  // wantconfirm
                buffer_put_int(msg, pvar->ssh_state.win_cols);  // columns
                buffer_put_int(msg, pvar->ssh_state.win_rows);  // lines
                buffer_put_int(msg, 480);  // XXX:
                buffer_put_int(msg, 640);  // XXX:
                len = buffer_len(msg);
                outmsg = begin_send_packet(pvar, SSH2_MSG_CHANNEL_REQUEST, len);
                memcpy(outmsg, buffer_ptr(msg), len);
                finish_send_packet(pvar);
                buffer_free(msg);

                notify_verbose_message(pvar, "SSH2_MSG_CHANNEL_REQUEST was sent at SSH_notify_win_size().", LOG_LEVEL_VERBOSE);

        } else {
                // SSH�����������������������B

        }

}

int SSH_get_min_packet_size(PTInstVar pvar)
{
        if (SSHv1(pvar)) {
                return 12;
        } else {
                int block_size = CRYPT_get_decryption_block_size(pvar);

                return max(16, block_size);
        }
}

/* data is guaranteed to be at least SSH_get_min_packet_size bytes long
   at least 5 bytes must be decrypted */
void SSH_predecrpyt_packet(PTInstVar pvar, char FAR * data)
{
        if (SSHv2(pvar)) {
                CRYPT_decrypt(pvar, data, get_predecryption_amount(pvar));
        }
}

int SSH_get_clear_MAC_size(PTInstVar pvar)
{
        if (SSHv1(pvar)) {
                return 0;
        } else {
                return CRYPT_get_receiver_MAC_size(pvar);
        }
}

void SSH_notify_user_name(PTInstVar pvar)
{
        try_send_user_name(pvar);
}

void SSH_notify_cred(PTInstVar pvar)
{
        try_send_credentials(pvar);
}

void SSH_send(PTInstVar pvar, unsigned char const FAR * buf, int buflen)
{
        if (SSHv1(pvar)) {
                if (get_handler(pvar, SSH_SMSG_STDOUT_DATA) != handle_data) {
                        return;
                }

                while (buflen > 0) {
                        int len =
                                buflen >
                                SSH_MAX_SEND_PACKET_SIZE ? SSH_MAX_SEND_PACKET_SIZE : buflen;
                        unsigned char FAR *outmsg =
                                begin_send_packet(pvar, SSH_CMSG_STDIN_DATA, 4 + len);

                        set_uint32(outmsg, len);

                        if (pvar->ssh_state.compressing) {
                                buf_ensure_size(&pvar->ssh_state.outbuf,
                                                                &pvar->ssh_state.outbuflen,
                                                                len + (len >> 6) + 50);
                                pvar->ssh_state.compress_stream.next_in =
                                        pvar->ssh_state.precompress_outbuf;
                                pvar->ssh_state.compress_stream.avail_in = 5;
                                pvar->ssh_state.compress_stream.next_out =
                                        pvar->ssh_state.outbuf + 12;
                                pvar->ssh_state.compress_stream.avail_out =
                                        pvar->ssh_state.outbuflen - 12;

                                if (deflate(&pvar->ssh_state.compress_stream, Z_NO_FLUSH) !=
                                        Z_OK) {
                                        notify_fatal_error(pvar, "Error compressing packet data");
                                        return;
                                }

                                pvar->ssh_state.compress_stream.next_in =
                                        (unsigned char FAR *) buf;
                                pvar->ssh_state.compress_stream.avail_in = len;

                                if (deflate(&pvar->ssh_state.compress_stream, Z_SYNC_FLUSH) !=
                                        Z_OK) {
                                        notify_fatal_error(pvar, "Error compressing packet data");
                                        return;
                                }
                        } else {
                                memcpy(outmsg + 4, buf, len);
                        }

                        finish_send_packet_special(pvar, 1);

                        buflen -= len;
                        buf += len;
                }

        } else { // for SSH2(yutaka)
                buffer_t *msg;
                unsigned char *outmsg;
                int len;
                Channel_t *c;

                c = ssh2_channel_lookup(pvar->shell_id);
                if (c == NULL)
                        return;

                msg = buffer_init();
                if (msg == NULL) {
                        // TODO: error check
                        return;
                }
                buffer_put_int(msg, c->remote_id);  
                buffer_put_string(msg, (char *)buf, buflen);  

                len = buffer_len(msg);
                outmsg = begin_send_packet(pvar, SSH2_MSG_CHANNEL_DATA, len);
                memcpy(outmsg, buffer_ptr(msg), len);
                finish_send_packet(pvar);
                buffer_free(msg);

                // remote window size������
                c->remote_window -= len;

        }

}

int SSH_extract_payload(PTInstVar pvar, unsigned char FAR * dest, int len)
{
        int num_bytes = pvar->ssh_state.payload_datalen;

        if (num_bytes > len) {
                num_bytes = len;
        }

        if (!pvar->ssh_state.decompressing) {
                memcpy(dest,
                           pvar->ssh_state.payload + pvar->ssh_state.payload_datastart,
                           num_bytes);
                pvar->ssh_state.payload_datastart += num_bytes;
        } else if (num_bytes > 0) {
                pvar->ssh_state.decompress_stream.next_out = dest;
                pvar->ssh_state.decompress_stream.avail_out = num_bytes;

                if (inflate(&pvar->ssh_state.decompress_stream, Z_SYNC_FLUSH) !=
                        Z_OK) {
                        notify_fatal_error(pvar,
                                                           "Invalid compressed data in received packet");
                        return 0;
                }
        }

        pvar->ssh_state.payload_datalen -= num_bytes;

        return num_bytes;
}

void SSH_get_compression_info(PTInstVar pvar, char FAR * dest, int len)
{
        char buf[1024];
        char buf2[1024];

        if (pvar->ssh_state.compressing) {
                unsigned long total_in = pvar->ssh_state.compress_stream.total_in;
                unsigned long total_out =
                        pvar->ssh_state.compress_stream.total_out;

                if (total_out > 0) {
                        _snprintf(buf, sizeof(buf), "level %d; ratio %.1f (%ld:%ld)",
                                          pvar->ssh_state.compression_level,
                                          ((double) total_in) / total_out, total_in,
                                          total_out);
                } else {
                        _snprintf(buf, sizeof(buf), "level %d",
                                          pvar->ssh_state.compression_level);
                }
        } else {
                strcpy(buf, "none");
        }
        buf[sizeof(buf) - 1] = 0;

        if (pvar->ssh_state.decompressing) {
                unsigned long total_in =
                        pvar->ssh_state.decompress_stream.total_in;
                unsigned long total_out =
                        pvar->ssh_state.decompress_stream.total_out;

                if (total_in > 0) {
                        _snprintf(buf2, sizeof(buf2), "level %d; ratio %.1f (%ld:%ld)",
                                          pvar->ssh_state.compression_level,
                                          ((double) total_out) / total_in, total_out,
                                          total_in);
                } else {
                        _snprintf(buf2, sizeof(buf2), "level %d",
                                          pvar->ssh_state.compression_level);
                }
        } else {
                strcpy(buf2, "none");
        }
        buf2[sizeof(buf2) - 1] = 0;

        _snprintf(dest, len, "Upstream %s; Downstream %s", buf, buf2);
        dest[len - 1] = 0;
}

void SSH_get_server_ID_info(PTInstVar pvar, char FAR * dest, int len)
{
        strncpy(dest, pvar->ssh_state.server_ID == NULL ? "Unknown"
                        : pvar->ssh_state.server_ID, len);
        dest[len - 1] = 0;
}

void SSH_get_protocol_version_info(PTInstVar pvar, char FAR * dest,
                                                                   int len)
{
        if (pvar->protocol_major == 0) {
                strncpy(dest, "Unknown", len);
        } else {
                _snprintf(dest, len, "%d.%d", pvar->protocol_major,
                                  pvar->protocol_minor);
        }
        dest[len - 1] = 0;
}

void SSH_end(PTInstVar pvar)
{
        int i;

        for (i = 0; i < 256; i++) {
                SSHPacketHandlerItem FAR *first_item =
                        pvar->ssh_state.packet_handlers[i];

                if (first_item != NULL) {
                        SSHPacketHandlerItem FAR *item = first_item;

                        do {
                                SSHPacketHandlerItem FAR *cur_item = item;

                                item = item->next_for_message;
                                free(cur_item);
                        } while (item != first_item);
                }
                pvar->ssh_state.packet_handlers[i] = NULL;
        }

        free(pvar->ssh_state.hostname);
        pvar->ssh_state.hostname = NULL;
        free(pvar->ssh_state.server_ID);
        pvar->ssh_state.server_ID = NULL;
        buf_destroy(&pvar->ssh_state.outbuf, &pvar->ssh_state.outbuflen);
        buf_destroy(&pvar->ssh_state.precompress_outbuf,
                                &pvar->ssh_state.precompress_outbuflen);
        buf_destroy(&pvar->ssh_state.postdecompress_inbuf,
                                &pvar->ssh_state.postdecompress_inbuflen);

        if (pvar->ssh_state.compressing) {
                deflateEnd(&pvar->ssh_state.compress_stream);
                pvar->ssh_state.compressing = FALSE;
        }
        if (pvar->ssh_state.decompressing) {
                inflateEnd(&pvar->ssh_state.decompress_stream);
                pvar->ssh_state.decompressing = FALSE;
        }

#if 1
        // SSH2���f�[�^���������� (2004.12.27 yutaka)
        if (SSHv2(pvar)) {
                if (pvar->kexdh) {
                        DH_free(pvar->kexdh);
                        pvar->kexdh = NULL;
                }
                memset(pvar->server_version_string, 0, sizeof(pvar->server_version_string));
                memset(pvar->client_version_string, 0, sizeof(pvar->client_version_string));

                if (pvar->my_kex != NULL) {
                        buffer_free(pvar->my_kex);
                        pvar->my_kex = NULL;
                }
                if (pvar->peer_kex != NULL) {
                        buffer_free(pvar->peer_kex);
                        pvar->peer_kex = NULL;
                }

                pvar->we_need = 0;
                pvar->key_done = 0;
                pvar->rekeying = 0;

                if (pvar->session_id != NULL) {
                        free(pvar->session_id);
                        pvar->session_id = NULL;
                }
                pvar->session_id_len = 0;

                pvar->userauth_success = 0;
                //pvar->remote_id = 0;
                pvar->shell_id = 0;
                pvar->session_nego_status = 0;

                pvar->ssh_heartbeat_tick = 0;
        }
#endif

}

/* support for port forwarding */
void SSH_channel_send(PTInstVar pvar, uint32 remote_channel_num,
                                          unsigned char FAR * buf, int len)
{
        unsigned char FAR *outmsg =
                begin_send_packet(pvar, SSH_MSG_CHANNEL_DATA, 8 + len);

        set_uint32(outmsg, remote_channel_num);
        set_uint32(outmsg + 4, len);

        if (pvar->ssh_state.compressing) {
                buf_ensure_size(&pvar->ssh_state.outbuf,
                                                &pvar->ssh_state.outbuflen, len + (len >> 6) + 50);
                pvar->ssh_state.compress_stream.next_in =
                        pvar->ssh_state.precompress_outbuf;
                pvar->ssh_state.compress_stream.avail_in = 9;
                pvar->ssh_state.compress_stream.next_out =
                        pvar->ssh_state.outbuf + 12;
                pvar->ssh_state.compress_stream.avail_out =
                        pvar->ssh_state.outbuflen - 12;

                if (deflate(&pvar->ssh_state.compress_stream, Z_NO_FLUSH) != Z_OK) {
                        notify_fatal_error(pvar, "Error compressing packet data");
                        return;
                }

                pvar->ssh_state.compress_stream.next_in =
                        (unsigned char FAR *) buf;
                pvar->ssh_state.compress_stream.avail_in = len;

                if (deflate(&pvar->ssh_state.compress_stream, Z_SYNC_FLUSH) !=
                        Z_OK) {
                        notify_fatal_error(pvar, "Error compressing packet data");
                        return;
                }
        } else {
                memcpy(outmsg + 8, buf, len);
        }

        finish_send_packet_special(pvar, 1);
}

void SSH_fail_channel_open(PTInstVar pvar, uint32 remote_channel_num)
{
        unsigned char FAR *outmsg =
                begin_send_packet(pvar, SSH_MSG_CHANNEL_OPEN_FAILURE, 4);

        set_uint32(outmsg, remote_channel_num);
        finish_send_packet(pvar);
}

void SSH_confirm_channel_open(PTInstVar pvar, uint32 remote_channel_num,
                                                          uint32 local_channel_num)
{
        unsigned char FAR *outmsg =
                begin_send_packet(pvar, SSH_MSG_CHANNEL_OPEN_CONFIRMATION, 8);

        set_uint32(outmsg, remote_channel_num);
        set_uint32(outmsg + 4, local_channel_num);
        finish_send_packet(pvar);
}

void SSH_channel_output_eof(PTInstVar pvar, uint32 remote_channel_num)
{
        unsigned char FAR *outmsg =
                begin_send_packet(pvar, SSH_MSG_CHANNEL_OUTPUT_CLOSED, 4);

        set_uint32(outmsg, remote_channel_num);
        finish_send_packet(pvar);
}

void SSH_channel_input_eof(PTInstVar pvar, uint32 remote_channel_num)
{
        unsigned char FAR *outmsg =
                begin_send_packet(pvar, SSH_MSG_CHANNEL_INPUT_EOF, 4);

        set_uint32(outmsg, remote_channel_num);
        finish_send_packet(pvar);
}

void SSH_request_forwarding(PTInstVar pvar, int from_server_port,
                                                        char FAR * to_local_host, int to_local_port)
{
        int host_len = strlen(to_local_host);
        unsigned char FAR *outmsg =
                begin_send_packet(pvar, 