ckonssh.c

/*
 *  C K O N S S H . C --  Null Subsystem Interface for Kermit 95
 *
 * Copyright (C) 2022, David Goodwin <david@zx.net.nz>
 *
 * 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.
 *  + Neither the name of Columbia University nor the names of any
 *    contributors may 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 COPYRIGHT
 * HOLDER 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.
 */

/*
 * This is a "null" SSH Subsystem for Kermit 95. It implements the bare
 * minimum to be loadable by Kermit 95, but it can't make SSH connections.
 *
 * It exists to serve as an example of Kermit 95s SSH Subsystem DLL
 * interface, and also to allow for performing some basic testing against
 * Kermit 95 without getting a full SSH implementation involved.
 *
 * Note that SSH Subsystems should *not* assume they're being loaded into
 * a graphical application. Kermit 95 is available in both GUI and text mode
 * (console) variants. The supplied helper functions uq_txt, uq_mtxt, uq_ok
 * and uq_file support both GUI and text-mode interfaces for getting user
 * input.
 */

#include "ckcdeb.h"
#include "ckossh.h"

#include <stdio.h>
#include <stdarg.h>

#ifdef NT
#include <windows.h>
#else
#define INCL_DOSPROCESS
#include <os2.h>
#undef COMMENT
#endif

/*
 * Keyword tables for some of the "set ssh" options - these are the tables whose
 * values are most likely to vary from one SSH implementation to another.
 *
 * These used to live in ckuus3.c
 */


#define SSHA_CRS   1
#define SSHA_DSA   2
#define SSHA_GSS   3
#define SSHA_HOS   4
#define SSHA_KBD   5
#define SSHA_K4    6
#define SSHA_K5    7
#define SSHA_PSW   8
#define SSHA_PK    9
#define SSHA_SKE  10
#define SSHA_TIS  11
#define SSHA_EXT  12
#define SSHA_SRP  13

static struct keytab ssh2aut[] = {      /* SET SSH V2 AUTH command table */
        { "external-keyx",      SSHA_EXT, 0 },
        { "gssapi",             SSHA_GSS, 0 },
        { "hostbased",          SSHA_HOS, 0 },
        { "keyboard-interactive",  SSHA_KBD, 0 },
        { "password",           SSHA_PSW, 0 },
        { "publickey",          SSHA_PK,  0 },
        { "srp-gex-sha1",       SSHA_SRP, 0 },
        { "", 0, 0 }
};
static int nssh2aut = (sizeof(ssh2aut) / sizeof(struct keytab)) - 1;

#define SSHC_3DES 1                     /* 3DES */
#define SSHC_3CBC 2                     /* 3DES-CBC */
#define SSHC_A128 3                     /* AES128-CBC */
#define SSHC_A192 4                     /* AES192-CBC */
#define SSHC_A256 5                     /* AES256-CBC */
#define SSHC_ARC4 6                     /* ARCFOUR */
#define SSHC_FISH 7                     /* BLOWFISH */
#define SSHC_C128 8                     /* CAST128-CBC */
#define SSHC_BCBC 9                     /* BLOWFISH-CBC */
#define SSHC_1DES 10                    /* DES */
#define SSHC_CHPO 11                    /* chachae20-poly1305 */
#define SSHC_A1GC 12                    /* aes128-gcm@openssh.com */
#define SSHC_A2GC 13                    /* aes256-gcm@openssh.com */
#define SSHC_A12C 14                    /* aes128-ctr */
#define SSHC_A19C 15                    /* aes192-ctr */
#define SSHC_A25C 16                    /* aes256-ctr */

static struct keytab ssh2ciphers[] = {  /* SET SSH V2 CIPHERS command table */
        { "3des-cbc",        SSHC_3CBC, 0 },
        { "aes128-cbc",      SSHC_A128, 0 },
        { "aes192-cbc",      SSHC_A192, 0 },
        { "aes256-cbc",      SSHC_A256, 0 },
        { "arcfour",         SSHC_ARC4, 0 },
        { "blowfish-cbc",    SSHC_FISH, 0 },
        { "cast128-cbc",     SSHC_C128, 0 },
        { "rijndael128-cbc", SSHC_A128, 0 },
        { "rijndael192-cbc", SSHC_A192, 0 },
        { "rijndael256-cbc", SSHC_A256, 0 },
        { "aes128-ctr", SSHC_A12C, 0 },
        { "aes192-ctr", SSHC_A19C, 0 },
        { "aes256-ctr", SSHC_A25C, 0 },
        { "aes128-gcm@openssh.com", SSHC_A1GC, 0 },
        { "aes256-gcm@openssh.com", SSHC_A2GC, 0 },
        { "chachae20-poly1305", SSHC_CHPO, 0 },
        { "", 0, 0 }
};
static int nssh2ciphers = (sizeof(ssh2ciphers) / sizeof(struct keytab)) - 1;

static struct keytab ssh1ciphers[] = {
    { "3des",         SSHC_3DES, 0 },
    { "blowfish",     SSHC_FISH, 0 },
    { "des",          SSHC_1DES, 0 },
    { "", 0, 0 }
};
static int nssh1ciphers = (sizeof(ssh1ciphers) / sizeof(struct keytab)) - 1;

#define SSHM_SHA        1               /* HMAC-SHA1 */
#define SSHM_SHA_96     2               /* HMAC-SHA1-96 */
#define SSHM_MD5        3               /* HMAC-MD5 */
#define SSHM_MD5_96     4               /* HMAC-MD5-96 */
#define SSHM_RIPE       5               /* HMAC-RIPEMD160 */
#define SSHM_SHA1_ETM   6               /* hmac-sha1-etm@openssh.com */
#define SSHM_SHA2_256   7               /* hmac-sha2-256 */
#define SSHM_SHA2_2ETM  8               /* hmac-sha2-256-etm@openssh.com */
#define SSHM_SHA2_512   9               /* hmac-sha2-512 */
#define SSHM_SHA2_5ETM  10              /* hmac-sha2-512-etm@openssh.com */
#define SSHM_NONE       11              /* none */

static struct keytab ssh2macs[] = {     /* SET SSH V2 MACS command table */
        { "hmac-md5",       SSHM_MD5,    0 },
        { "hmac-md5-96",    SSHM_MD5_96, 0 },
        { "hmac-ripemd160", SSHM_RIPE,   0 },
        { "hmac-sha1",      SSHM_SHA,    0 },
        { "hmac-sha1-96",   SSHM_SHA_96, 0 },
        { "hmac-sha1-etm@openssh.com",      SSHM_SHA1_ETM,    0 },
        { "hmac-sha2-256",                  SSHM_SHA2_256,    0 },
        { "hmac-sha2-256-etm@openssh.com",  SSHM_SHA2_2ETM,    0 },
        { "hmac-sha2-512",                  SSHM_SHA2_512,    0 },
        { "hmac-sha2-512-etm@openssh.com",  SSHM_SHA2_5ETM,    0 },
        { "none",                           SSHM_NONE,    0 },
        { "", 0, 0 }
};
static int nssh2macs = (sizeof(ssh2macs) / sizeof(struct keytab)) - 1;

#define HKA_RSA 1
#define HKA_DSS 2
#define HKA_EC2 3
#define HKA_EC3 4
#define HKA_EC5 5
#define HKA_ED2 6
#define HKA_S22 7
#define HKA_S25 8

static struct keytab hkatab[] = {
        { "ecdsa-sha2-nistp256", HKA_EC2, 0, },
        { "ecdsa-sha2-nistp384", HKA_EC3, 0, },
        { "ecdsa-sha2-nistp521", HKA_EC5, 0, },
        { "rsa-sha2-256", HKA_S22, 0, },
        { "rsa-sha2-512", HKA_S25, 0, },
        { "ssh-dss", HKA_DSS, 0, },
        { "ssh-ed25519", HKA_ED2, 0, },
        { "ssh-rsa", HKA_RSA, 0, },
        { "", 0, 0 }
};
static int nhkatab = (sizeof(hkatab) / sizeof(struct keytab)) - 1;

static struct keytab sshkextab[] = {
        { "curve25519-sha256",              1, 0, },
        { "curve25519-sha256@libssh.org",   2, 0, },
        { "diffie-hellman-group1-sha1",     3, 0, },
        { "diffie-hellman-group14-sha1",    4, 0, },
        { "diffie-hellman-group14-sha256",  5, 0, },
        { "diffie-hellman-group16-sha512",  6, 0, },
        { "diffie-hellman-group18-sha512",  7, 0, },
        { "diffie-hellman-group-exchange-sha1",   8, 0, },
        { "diffie-hellman-group-exchange-sha256", 9, 0, },
        { "ecdh-sha2-nistp256",             10, 0, },
        { "ecdh-sha2-nistp384",             11, 0, },
        { "ecdh-sha2-nistp521",             12, 0, },
        { "ext-info-c",                     13, 0, },
        { "", 0, 0 }
};
static int nsshkextab = (sizeof(sshkextab) / sizeof(struct keytab)) - 1;

#define SET_OFF  0

/* Integer parameters accessed via ssh_set_iparam and ssh_get_iparam */
static int                                     /* SET SSH variables */
ssh_afw = 0,                          /* agent forwarding */
ssh_xfw = 0,                          /* x11 forwarding   */
ssh_prp = SET_OFF,                    /* privileged ports */
ssh_cmp = 1,                          /* compression */
ssh_cas = 0,                          /* command as subsys */
ssh_shh = 0,                          /* quiet       */
ssh_ver = 0,                          /* protocol version (auto,1,2) */
ssh_vrb = 2,                          /* Report errors */
ssh_chkip = 0,                        /* SSH Check Host IP flag */
ssh_gwp = 0,                          /* gateway ports */
ssh_dyf = 0,                          /* dynamic forwarding */
ssh_gsd = 0,                          /* gssapi delegate credentials */
ssh_k4tgt = 0,                        /* k4 tgt passing */
ssh_k5tgt = 0,                        /* k5 tgt passing */
ssh_shk = 2,                          /* Strict host key (no, yes, ask) */
ssh2_ark = 1,                         /* Auto re-key */
ssh_cfg = 0,                          /* use OpenSSH config? */
ssh_gkx = 1,                          /* gssapi key exchange */
ssh_k5_is_k4 = 1,                     /* some SSH v1 use same codes */
ssh_hbt = 0,                          /* heartbeat (seconds) */
ssh_dummy = 0;                        /* bottom of list */

/* String parameters accessed via ssh_set_sparam and ssh_get_sparam */
static char                             /* The following are to be malloc'd */
* ssh1_cif = NULL,                    /* v1 cipher */
* ssh2_cif = NULL,                    /* v2 cipher list */
* ssh2_mac = NULL,                    /* v2 mac list */
* ssh2_auth = NULL,                   /* v2 authentication list */
* ssh2_hka = NULL,                    /* Host Key Algorithms */
* ssh_hst = NULL,                     /* hostname */
* ssh_prt = NULL,                     /* port/service */
* ssh_cmd = NULL,                     /* command to execute */
* ssh_xal = NULL,                     /* xauth-location */
* ssh1_gnh = NULL,                    /* v1 global known hosts file */
* ssh1_unh = NULL,                    /* v1 user known hosts file */
* ssh2_gnh = NULL,                    /* v2 global known hosts file */
* ssh2_unh = NULL,                    /* v2 user known hosts file */
* ssh2_kex = NULL,                    /* Key Exchange Methods */
* ssh_pxc = NULL,                     /* Proxy command */
* ssh_dir = NULL,                     /* SSH Directory */
* xxx_dummy = NULL;

#ifdef SSH_DLL

static get_current_terminal_dimensions_callback *callbackp_get_current_terminal_dimensions = NULL;
static get_current_terminal_type_callback   *callbackp_get_current_terminal_type = NULL;
static ssh_get_uid_callback                 *callbackp_ssh_get_uid = NULL;
static ssh_get_pw_callback                  *callbackp_ssh_get_pw = NULL;
static ssh_get_nodelay_enabled_callback     *callbackp_ssh_get_nodelay_enabled = NULL;
static ssh_open_socket_callback             *callbackp_ssh_open_socket = NULL;
static dodebug_callback                     *callbackp_dodebug = NULL;
static scrnprint_callback                   *callbackp_scrnprint = NULL;
static uq_txt_callback                      *callbackp_uq_txt = NULL;
static uq_mtxt_callback                     *callbackp_uq_mtxt = NULL;
static uq_ok_callback                       *callbackp_uq_ok = NULL;
static uq_file_callback                     *callbackp_uq_file = NULL;
static zmkdir_callback                      *callbackp_zmkdir = NULL;
static ckmakxmsg_callback                   *callbackp_ckmakxmsg = NULL;
static whoami_callback                      *callbackp_whoami = NULL;
static GetAppData_callback                  *callbackp_GetAppData = NULL;
static GetHomePath_callback                 *callbackp_GetHomePath = NULL;
static GetHomeDrive_callback                *callbackp_GetHomeDrive = NULL;
static ckstrncpy_callback                   *callbackp_ckstrncpy = NULL;
static debug_logging_callback               *callbackp_debug_logging = NULL;
static get_display_callback                 *callbackp_get_display = NULL;
static parse_displayname_callback           *callbackp_parse_displayname = NULL;

void get_current_terminal_dimensions(int* rows, int* cols) {
    callbackp_get_current_terminal_dimensions(rows, cols);
}

const char* get_current_terminal_type(void) {
    return callbackp_get_current_terminal_type();
}

const char* ssh_get_uid(void) {
    return callbackp_ssh_get_uid();
}

const char* ssh_get_pw(void) {
    return callbackp_ssh_get_pw();
}

int ssh_get_nodelay_enabled(void) {
    return callbackp_ssh_get_nodelay_enabled();
}

SOCKET ssh_open_socket(char* host, char* port) {
    return callbackp_ssh_open_socket(host, port);
}

int dodebug(int flag, char * s1, char * s2, CK_OFF_T n)
{
    if ( callbackp_dodebug )
        return(callbackp_dodebug(flag,s1,s2,n));
    else
        return(-1);
}

static char myprtfstr[4096];
int Vscrnprintf(const char * format, ...) {
    int i, len, rc=0;
    char *cp;
    va_list ap;

    va_start(ap, format);
#ifdef NT
    rc = _vsnprintf(myprtfstr, sizeof(myprtfstr)-1, format, ap);
#else /* NT */
    rc = vsprintf(myprtfstr, format, ap);
#endif /* NT */
    va_end(ap);

    if ( callbackp_scrnprint )
        return(callbackp_scrnprint(myprtfstr));
    else
        return(-1);
}

int uq_txt(char * preface, char * prompt, int echo, char ** help, char * buf,
       int buflen, char *dflt, int timer) {
    return callbackp_uq_txt(preface, prompt, echo, help, buf, buflen, dflt, timer);
}

int uq_mtxt(char * preface,char **help, int n, struct txtbox field[]) {
    return callbackp_uq_mtxt(preface, help, n, field);
}

int uq_ok(char * preface, char * prompt, int mask,char ** help, int dflt) {
    return callbackp_uq_ok(preface, prompt, mask, help, dflt);
}

int uq_file(char * preface, char * fprompt, int fc, char ** help,
	char * dflt, char * result, int rlength) {
    return callbackp_uq_file(preface, fprompt, fc, help, dflt, result, rlength);
}

int zmkdir(char *path) {
    return callbackp_zmkdir(path);
}

int ckmakxmsg(char * buf, int len, char *s1, char *s2, char *s3,
        char *s4, char *s5, char *s6, char *s7, char *s8, char *s9,
        char *s10, char *s11, char *s12) {
    return callbackp_ckmakxmsg(buf, len, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11,
                       s12);
}

char* whoami(void) {
    return callbackp_whoami();
}

char* GetAppData(int common) {
    return callbackp_GetAppData(common);
}

char* GetHomePath(void) {
    return callbackp_GetHomePath();
}

char* GetHomeDrive(void) {
    return callbackp_GetHomeDrive();
}

int ckstrncpy(char * dest, const char * src, int len) {
    return callbackp_ckstrncpy(dest, src, len);
}

int debug_logging(void) {
    return callbackp_debug_logging();
}

unsigned char* get_display(void) {
    return callbackp_get_display();
}

int parse_displayname(char *displayname, int *familyp, char **hostp,
                        int *dpynump, int *scrnump, char **restp) {
    return callbackp_parse_displayname(displayname, familyp, hostp,
                               dpynump, scrnump, restp);
}

#ifdef SSH_DLL_CALLCONV

/* define prototypes for DLL functions */
static ssh_set_iparam_dllfunc               dllfunc_ssh_set_iparam;
static ssh_get_iparam_dllfunc               dllfunc_ssh_get_iparam;
static ssh_set_sparam_dllfunc               dllfunc_ssh_set_sparam;
static ssh_get_sparam_dllfunc               dllfunc_ssh_get_sparam;
static ssh_set_identity_files_dllfunc       dllfunc_ssh_set_identity_files;
static ssh_get_socket_dllfunc               dllfunc_ssh_get_socket;
static ssh_open_dllfunc                     dllfunc_ssh_open;
static ssh_clos_dllfunc                     dllfunc_ssh_clos;
static ssh_tchk_dllfunc                     dllfunc_ssh_tchk;
static ssh_flui_dllfunc                     dllfunc_ssh_flui;
static ssh_break_dllfunc                    dllfunc_ssh_break;
static ssh_inc_dllfunc                      dllfunc_ssh_inc;
static ssh_xin_dllfunc                      dllfunc_ssh_xin;
static ssh_toc_dllfunc                      dllfunc_ssh_toc;
static ssh_tol_dllfunc                      dllfunc_ssh_tol;
static ssh_snaws_dllfunc                    dllfunc_ssh_snaws;
static ssh_proto_ver_dllfunc                dllfunc_ssh_proto_ver;
static ssh_impl_ver_dllfunc                 dllfunc_ssh_impl_ver;
static sshkey_create_dllfunc                dllfunc_sshkey_create;
static sshkey_display_fingerprint_dllfunc   dllfunc_sshkey_display_fingerprint;
static sshkey_display_public_dllfunc        dllfunc_sshkey_display_public;
static sshkey_display_public_as_ssh2_dllfunc dllfunc_sshkey_display_public_as_ssh2;
static sshkey_change_passphrase_dllfunc     dllfunc_sshkey_change_passphrase;
static ssh_fwd_remote_port_dllfunc          dllfunc_ssh_fwd_remote_port;
static ssh_fwd_local_port_dllfunc           dllfunc_ssh_fwd_local_port;
static ssh_fwd_clear_remote_ports_dllfunc   dllfunc_ssh_fwd_clear_remote_ports;
static ssh_fwd_clear_local_ports_dllfunc    dllfunc_ssh_fwd_clear_local_ports;
static ssh_fwd_remove_remote_port_dllfunc   dllfunc_ssh_fwd_remove_remote_port;
static ssh_fwd_remove_local_port_dllfunc    dllfunc_ssh_fwd_remove_local_port;
static ssh_fwd_get_ports_dllfunc            dllfunc_ssh_fwd_get_ports;
static sshkey_v1_change_comment_dllfunc     dllfunc_sshkey_v1_change_comment;
static sshkey_default_file_dllfunc          dllfunc_sshkey_default_file;
static ssh_v2_rekey_dllfunc                 dllfunc_ssh_v2_rekey;
static ssh_agent_delete_file_dllfunc        dllfunc_ssh_agent_delete_file;
static ssh_agent_delete_all_dllfunc         dllfunc_ssh_agent_delete_all;
static ssh_agent_add_file_dllfunc           dllfunc_ssh_agent_add_file;
static ssh_agent_list_identities_dllfunc    dllfunc_ssh_agent_list_identities;
static ssh_unload_dllfunc                   dllfunc_ssh_unload;
static ssh_dll_ver_dllfunc                  dllfunc_ssh_dll_ver;
static ssh_get_keytab_dllfunc               dllfunc_ssh_get_keytab;
static ssh_feature_supported_dllfunc        dllfunc_ssh_feature_supported;
static ssh_get_set_help_dllfunc             dllfunc_ssh_get_set_help;
static ssh_get_help_dllfunc                 dllfunc_ssh_get_help;


/* calling convention layer for DLL functions on DLL side */
static int CKSSHAPI dllfunc_ssh_set_iparam(int param, int value) {
    return ssh_set_iparam(param, value);
}

static int CKSSHAPI dllfunc_ssh_get_iparam(int param) {
    return ssh_get_iparam(param);
}

static int CKSSHAPI dllfunc_ssh_set_sparam(int param, const char* value) {
    return ssh_set_sparam(param, value);
}

static const char* CKSSHAPI dllfunc_ssh_get_sparam(int param) {
    return ssh_get_sparam(param);
}

static int CKSSHAPI dllfunc_ssh_set_identity_files(const char** identity_files) {
    return ssh_set_identity_files(identity_files);
}

static int CKSSHAPI dllfunc_ssh_get_socket(void) {
    return ssh_get_socket();
}

static int CKSSHAPI dllfunc_ssh_open(void) {
    return ssh_open();
}

static int CKSSHAPI dllfunc_ssh_clos(void) {
    return ssh_clos();
}

static int CKSSHAPI dllfunc_ssh_tchk(void) {
    return ssh_tchk();
}

static int CKSSHAPI dllfunc_ssh_flui(void) {
    return ssh_flui();
}

static int CKSSHAPI dllfunc_ssh_break(void) {
    return ssh_break();
}

static int CKSSHAPI dllfunc_ssh_inc(int timeout) {
    return ssh_inc(timeout);
}

static int CKSSHAPI dllfunc_ssh_xin(int count, char * buffer) {
    return ssh_xin(count, buffer);
}

static int CKSSHAPI dllfunc_ssh_toc(int c) {
    return ssh_toc(c);
}

static int CKSSHAPI dllfunc_ssh_tol(char * buffer, int count) {
    return ssh_tol(buffer, count);
}

static int CKSSHAPI dllfunc_ssh_snaws(void) {
    return ssh_snaws();
}

static const char * CKSSHAPI dllfunc_ssh_proto_ver(void) {
    return ssh_proto_ver();
}

static const char * CKSSHAPI dllfunc_ssh_impl_ver(void) {
    return ssh_impl_ver();
}

#ifdef COMMENT
static int CKSSHAPI dllfunc_sshkey_create(char * filename, int bits, char * pp,
                             int type, char * cmd_comment) {
    return sshkey_create(filename, bits, pp, type, cmd_comment);
}

static int CKSSHAPI dllfunc_sshkey_display_fingerprint(char * filename, int babble) {
    return sshkey_display_fingerprint(filename, babble);
}

static int CKSSHAPI dllfunc_sshkey_display_public(char * filename, char *identity_passphrase) {
    return sshkey_display_public(filename, identity_passphrase);
}

static int CKSSHAPI dllfunc_sshkey_display_public_as_ssh2(char * filename,char *identity_passphrase) {
    return sshkey_display_public_as_ssh2(filename, identity_passphrase);
}

static int CKSSHAPI dllfunc_sshkey_change_passphrase(char * filename, char * oldpp, char * newpp) {
    return sshkey_change_passphrase(filename, oldpp, newpp);
}

static int CKSSHAPI dllfunc_ssh_fwd_remote_port(char* address, int port, char * host, int host_port, BOOL apply) {
    return ssh_fwd_remote_port(address, port, host, host_port, apply);
}

static int CKSSHAPI dllfunc_ssh_fwd_local_port(char* address, int port,char * host, int host_port, BOOL apply) {
    return ssh_fwd_local_port(address, port, host, host_port, apply);
}

static int CKSSHAPI dllfunc_ssh_fwd_clear_remote_ports(BOOL apply) {
    return ssh_fwd_clear_remote_ports(apply);
}

static int CKSSHAPI dllfunc_ssh_fwd_clear_local_ports(BOOL apply) {
    return ssh_fwd_clear_local_ports(apply);
}

static int CKSSHAPI dllfunc_ssh_fwd_remove_remote_port(int port, BOOL apply) {
    return ssh_fwd_remove_remote_port(port, apply);
}

static int CKSSHAPI dllfunc_ssh_fwd_remove_local_port(int port, BOOL apply) {
    return ssh_fwd_remove_local_port(port, apply);
}

static const ssh_port_forward_t* CKSSHAPI dllfunc_ssh_fwd_get_ports(void) {
    return ssh_fwd_get_ports();
}

#ifdef SSHTEST
static int CKSSHAPI dllfunc_sshkey_v1_change_comment(char * filename, char * comment, char * pp) {
    return sshkey_v1_change_comment(filename, comment, pp);
}
#endif /* SSHTEST */

#ifdef COMMENT
static char * CKSSHAPI dllfunc_sshkey_default_file(int a) {
    return sshkey_default_file(a);
}
#endif /* COMMENT */

static void CKSSHAPI dllfunc_ssh_v2_rekey(void) {
    ssh_v2_rekey();
}

static int CKSSHAPI dllfunc_ssh_agent_delete_file(const char *filename) {
    return ssh_agent_delete_file(filename);
}

static int CKSSHAPI dllfunc_ssh_agent_delete_all(void) {
    return ssh_agent_delete_all();
}

static int CKSSHAPI dllfunc_ssh_agent_add_file(const char *filename) {
    return ssh_agent_add_file(filename);
}

static int CKSSHAPI dllfunc_ssh_agent_list_identities(int do_fp) {
    return ssh_agent_list_identities(do_fp);
}

static void CKSSHAPI dllfunc_ssh_unload(void) {
    ssh_unload();
}
#endif /* COMMENT */

static const char * CKSSHAPI dllfunc_ssh_dll_ver(void) {
    return ssh_dll_ver();
}

static ktab_ret CKSSHAPI dllfunc_ssh_get_keytab(int keytab_id) {
    return ssh_get_keytab(keytab_id);
}

static int CKSSHAPI dllfunc_ssh_feature_supported(int feature_id) {
    return ssh_feature_supported(feature_id);
}

static const char ** CKSSHAPI dllfunc_ssh_get_set_help(void) {
    return ssh_get_set_help();
}

static const char ** CKSSHAPI dllfunc_ssh_get_help(void) {
    return ssh_get_help();
}

#else /* SSH_DLL_CALLCONV */

/* directly use DLL functions without calling convention layer */
#define dllfunc_ssh_set_iparam              ssh_set_iparam
#define dllfunc_ssh_get_iparam              ssh_get_iparam
#define dllfunc_ssh_set_sparam              ssh_set_sparam
#define dllfunc_ssh_get_sparam              ssh_get_sparam
#define dllfunc_ssh_set_identity_files      ssh_set_identity_files
#define dllfunc_ssh_get_socket              ssh_get_socket
#define dllfunc_ssh_open                    ssh_open
#define dllfunc_ssh_clos                    ssh_clos
#define dllfunc_ssh_tchk                    ssh_tchk
#define dllfunc_ssh_flui                    ssh_flui
#define dllfunc_ssh_break                   ssh_break
#define dllfunc_ssh_inc                     ssh_inc
#define dllfunc_ssh_xin                     ssh_xin
#define dllfunc_ssh_toc                     ssh_toc
#define dllfunc_ssh_tol                     ssh_tol
#define dllfunc_ssh_snaws                   ssh_snaws
#define dllfunc_ssh_proto_ver               ssh_proto_ver
#define dllfunc_ssh_impl_ver                ssh_impl_ver
#ifdef COMMENT
#define dllfunc_sshkey_create               sshkey_create
#define dllfunc_sshkey_display_fingerprint  sshkey_display_fingerprint
#define dllfunc_sshkey_display_public       sshkey_display_public
#define dllfunc_sshkey_display_public_as_ssh2 sshkey_display_public_as_ssh2
#define dllfunc_sshkey_change_passphrase    sshkey_change_passphrase
#define dllfunc_ssh_fwd_remote_port         ssh_fwd_remote_port
#define dllfunc_ssh_fwd_local_port          ssh_fwd_local_port
#define dllfunc_ssh_fwd_clear_remote_ports  ssh_fwd_clear_remote_ports
#define dllfunc_ssh_fwd_clear_local_ports   ssh_fwd_clear_local_ports
#define dllfunc_ssh_fwd_remove_remote_port  ssh_fwd_remove_remote_port
#define dllfunc_ssh_fwd_remove_local_port   ssh_fwd_remove_local_port
#define dllfunc_ssh_fwd_get_ports           ssh_fwd_get_ports
#ifdef SSHTEST
#define dllfunc_sshkey_v1_change_comment    sshkey_v1_change_comment
#endif /* SSHTEST */
#ifdef COMMENT
#define dllfunc_sshkey_default_file         sshkey_default_file
#endif /* COMMENT */
#define dllfunc_ssh_v2_rekey                ssh_v2_rekey
#define dllfunc_ssh_agent_delete_file       ssh_agent_delete_file
#define dllfunc_ssh_agent_delete_all        ssh_agent_delete_all
#define dllfunc_ssh_agent_add_file          ssh_agent_add_file
#define dllfunc_ssh_agent_list_identities   ssh_agent_list_identities
#define dllfunc_ssh_unload                  ssh_unload
#endif /* COMMENT */
#define dllfunc_ssh_dll_ver                 ssh_dll_ver
#define dllfunc_ssh_get_keytab              ssh_get_keytab
#define dllfunc_ssh_feature_supported       ssh_feature_supported
#define dllfunc_ssh_get_set_help            ssh_get_set_help
#define dllfunc_ssh_get_help                ssh_get_help

#endif /* SSH_DLL_CALLCONV */

/*
 * Quick macro to check if a function pointer is null and, if it is, log
 * the event and return an error.
 */
#define CHECK_FP(fp)

/** Called by Kermit 95 when the DLL is loaded. This should make
 * the DLL ready for use by storing copies of all the needed
 * callback functions supplied by Kermit 95, and supplying to
 * Kermit 95 via the install_dllfunc all of the SSH functions
 * this DLL provides.
 * @param params SSH initialisation parameters from Kermit 95
 */
int CKSSHDLLENTRY ssh_dll_init(ssh_dll_init_data *init) {
    /* Store pointers to helper functions provided by K95 */
    callbackp_get_current_terminal_dimensions = init->callbackp_get_current_terminal_dimensions;
    CHECK_FP(callbackp_get_current_terminal_dimensions)
    callbackp_get_current_terminal_type = init->callbackp_get_current_terminal_type;
    CHECK_FP(callbackp_get_current_terminal_type)
    callbackp_ssh_get_uid = init->callbackp_ssh_get_uid;
    CHECK_FP(callbackp_ssh_get_uid)
    callbackp_ssh_get_pw = init->callbackp_ssh_get_pw;
    CHECK_FP(callbackp_ssh_get_pw)
    callbackp_ssh_get_nodelay_enabled = init->callbackp_ssh_get_nodelay_enabled;
    CHECK_FP(callbackp_ssh_get_nodelay_enabled)
    callbackp_ssh_open_socket = init->callbackp_ssh_open_socket;
    CHECK_FP(callbackp_ssh_open_socket)
    callbackp_dodebug = init->callbackp_dodebug;
    CHECK_FP(callbackp_dodebug)
    callbackp_scrnprint = init->callbackp_scrnprint;
    CHECK_FP(callbackp_scrnprint)
    callbackp_uq_txt = init->callbackp_uq_txt;
    CHECK_FP(callbackp_uq_txt)
    callbackp_uq_mtxt = init->callbackp_uq_mtxt;
    CHECK_FP(callbackp_uq_mtxt)
    callbackp_uq_ok = init->callbackp_uq_ok;
    CHECK_FP(callbackp_uq_ok)
    callbackp_uq_file = init->callbackp_uq_file;
    CHECK_FP(callbackp_uq_file)
    callbackp_zmkdir = init->callbackp_zmkdir;
    CHECK_FP(callbackp_zmkdir)
    callbackp_ckmakxmsg = init->callbackp_ckmakxmsg;
    CHECK_FP(callbackp_ckmakxmsg)
    callbackp_whoami = init->callbackp_whoami;
    CHECK_FP(callbackp_whoami)
    callbackp_GetAppData = init->callbackp_GetAppData;
    CHECK_FP(callbackp_GetAppData)
    callbackp_GetHomePath = init->callbackp_GetHomePath;
    CHECK_FP(callbackp_GetHomePath)
    callbackp_GetHomeDrive = init->callbackp_GetHomeDrive;
    CHECK_FP(callbackp_GetHomeDrive)
    callbackp_ckstrncpy = init->callbackp_ckstrncpy;
    CHECK_FP(callbackp_ckstrncpy)
    callbackp_debug_logging = init->callbackp_debug_logging;
    CHECK_FP(callbackp_debug_logging)
    callbackp_get_display = init->callbackp_get_display;
    CHECK_FP(callbackp_get_display)
    callbackp_parse_displayname = init->callbackp_parse_displayname;
    CHECK_FP(callbackp_parse_displayname)

    init->callbackp_install_dllfunc("ssh_set_iparam", dllfunc_ssh_set_iparam);
    init->callbackp_install_dllfunc("ssh_get_iparam", dllfunc_ssh_get_iparam);
    init->callbackp_install_dllfunc("ssh_set_sparam", dllfunc_ssh_set_sparam);
    init->callbackp_install_dllfunc("ssh_get_sparam", dllfunc_ssh_get_sparam);
    init->callbackp_install_dllfunc("ssh_set_identity_files", dllfunc_ssh_set_identity_files);
    init->callbackp_install_dllfunc("ssh_get_socket", dllfunc_ssh_get_socket);
    init->callbackp_install_dllfunc("ssh_open", dllfunc_ssh_open);
    init->callbackp_install_dllfunc("ssh_clos", dllfunc_ssh_clos);
    init->callbackp_install_dllfunc("ssh_tchk", dllfunc_ssh_tchk);
    init->callbackp_install_dllfunc("ssh_flui", dllfunc_ssh_flui);
    init->callbackp_install_dllfunc("ssh_break", dllfunc_ssh_break);
    init->callbackp_install_dllfunc("ssh_inc", dllfunc_ssh_inc);
    init->callbackp_install_dllfunc("ssh_xin", dllfunc_ssh_xin);
    init->callbackp_install_dllfunc("ssh_toc", dllfunc_ssh_toc);
    init->callbackp_install_dllfunc("ssh_tol", dllfunc_ssh_tol);
    init->callbackp_install_dllfunc("ssh_snaws", dllfunc_ssh_snaws);
    init->callbackp_install_dllfunc("ssh_proto_ver", dllfunc_ssh_proto_ver);
    init->callbackp_install_dllfunc("ssh_impl_ver", dllfunc_ssh_impl_ver);

    /* These functions are all optional */
#ifdef COMMENT
    init->callbackp_install_dllfunc("sshkey_create", dllfunc_sshkey_create);
    init->callbackp_install_dllfunc("sshkey_display_fingerprint", dllfunc_sshkey_display_fingerprint);
    init->callbackp_install_dllfunc("sshkey_display_public", dllfunc_sshkey_display_public);
    init->callbackp_install_dllfunc("sshkey_display_public_as_ssh2", dllfunc_sshkey_display_public_as_ssh2);
    init->callbackp_install_dllfunc("sshkey_change_passphrase", dllfunc_sshkey_change_passphrase);
    init->callbackp_install_dllfunc("ssh_fwd_remote_port", dllfunc_ssh_fwd_remote_port);
    init->callbackp_install_dllfunc("ssh_fwd_local_port", dllfunc_ssh_fwd_local_port);
    init->callbackp_install_dllfunc("ssh_fwd_clear_remote_ports", dllfunc_ssh_fwd_clear_remote_ports);
    init->callbackp_install_dllfunc("ssh_fwd_clear_local_ports", dllfunc_ssh_fwd_clear_local_ports);
    init->callbackp_install_dllfunc("ssh_fwd_remove_remote_port", dllfunc_ssh_fwd_remove_remote_port);
    init->callbackp_install_dllfunc("ssh_fwd_remove_local_port", dllfunc_ssh_fwd_remove_local_port);
    init->callbackp_install_dllfunc("ssh_fwd_get_ports", dllfunc_ssh_fwd_get_ports);
#ifdef SSHTEST
    init->callbackp_install_dllfunc("sshkey_v1_change_comment", dllfunc_sshkey_v1_change_comment); /* TODO */
#endif /* SSHTEST */
#ifdef COMMENT
    init->callbackp_install_dllfunc("sshkey_default_file", dllfunc_sshkey_default_file); */ /* TODO */
#endif /* COMMENT */
    init->callbackp_install_dllfunc("ssh_v2_rekey", dllfunc_ssh_v2_rekey); /* TODO */
    init->callbackp_install_dllfunc("ssh_agent_delete_file", dllfunc_ssh_agent_delete_file); /* TODO */
    init->callbackp_install_dllfunc("ssh_agent_delete_all", dllfunc_ssh_agent_delete_all); /* TODO */
    init->callbackp_install_dllfunc("ssh_agent_add_file", dllfunc_ssh_agent_add_file); /* TODO */
    init->callbackp_install_dllfunc("ssh_agent_list_identities", dllfunc_ssh_agent_list_identities); /* TODO */
#ifdef COMMENT
    /* Not supported: */
    init->callbackp_install_dllfunc("ssh_unload", dllfunc_ssh_unload);
#endif /* COMMENT */
#endif /* COMMENT */
    init->callbackp_install_dllfunc("ssh_dll_ver", dllfunc_ssh_dll_ver);
    init->callbackp_install_dllfunc("ssh_get_keytab", dllfunc_ssh_get_keytab);
    init->callbackp_install_dllfunc("ssh_feature_supported", dllfunc_ssh_feature_supported);
    init->callbackp_install_dllfunc("ssh_get_set_help", dllfunc_ssh_get_set_help);
    init->callbackp_install_dllfunc("ssh_get_help", dllfunc_ssh_get_help);

    return 0;
}

#undef malloc
#undef realloc
#undef free
#undef strdup

void
fatal(char *msg) {
    if (!msg) msg = "";

    printf(msg);
    exit(1);        /* Exit indicating failure */
}

void *
kmalloc(size_t size)
{
    void *ptr;

    if (size == 0) {
        fatal("kmalloc: zero size");
    }
    ptr = malloc(size);
    if (ptr == NULL) {
        fatal("kmalloc: out of memory");
    }
    return ptr;
}

void *
krealloc(void *ptr, size_t new_size)
{
    void *new_ptr;

    if (new_size == 0) {
        fatal("krealloc: zero size");
    }
    if (ptr == NULL)
        new_ptr = malloc(new_size);
    else
        new_ptr = realloc(ptr, new_size);
    if (new_ptr == NULL) {
        fatal("krealloc: out of memory");
    }
    return new_ptr;
}

void
kfree(void *ptr)
{
    if (ptr == NULL) {
        printf("kfree: NULL pointer given as argument");
        return;
    }
    free(ptr);
}

char *
kstrdup(const char *str)
{
    size_t len;
    char *cp;

    if (str == NULL) {
        fatal("kstrdup: NULL pointer given as argument");
    }
    len = strlen(str) + 1;
    cp = kmalloc(len);
    if (cp)
        memcpy(cp, str, len);
    return cp;
}

#endif /* SSH_DLL */

/** Sets an integer parameter
 *
 * @param param Parameter to set
 * @param value New value
 * @return
 */
int ssh_set_iparam(int param, int value) {
    switch(param) {
        case SSH_IPARAM_AFW:
            ssh_afw = value;
            break;
        case SSH_IPARAM_XFW:
            ssh_xfw = value;
            break;
        case SSH_IPARAM_PRP:
            ssh_prp = value;
            break;
        case SSH_IPARAM_CMP:
            ssh_cmp = value;
            break;
        case SSH_IPARAM_CAS:
            ssh_cas = value;
            break;
        case SSH_IPARAM_SHH:
            ssh_shh = value;
            break;
        case SSH_IPARAM_VER:
            ssh_ver = value;
            break;
        case SSH_IPARAM_VRB:
            ssh_vrb = value;
            break;
        case SSH_IPARAM_CHKIP:
            ssh_chkip = value;
            break;
        case SSH_IPARAM_GWP:
            ssh_gwp = value;
            break;
        case SSH_IPARAM_DYF:
            ssh_dyf = value;
            break;
        case SSH_IPARAM_GSD:
            ssh_gsd = value;
            break;
        case SSH_IPARAM_K4TGT:
            ssh_k4tgt = value;
            break;
        case SSH_IPARAM_K5TGT:
            ssh_k5tgt = value;
            break;
        case SSH_IPARAM_SHK:
            ssh_shk = value;
            break;
        case SSH_IPARAM_2_ARK:
            ssh2_ark = value;
            break;
        case SSH_IPARAM_CFG:
            ssh_cfg = value;
            break;
        case SSH_IPARAM_GKX:
            ssh_gkx = value;
            break;
        case SSH_IPARAM_K5_IS_K4:
            ssh_k5_is_k4 = value;
            break;
        case SSH_IPARAM_HBT:
            ssh_hbt = value;
            break;
        default:
            return 1;
    }
    return 0;
}

/** Gets an integer parameter
 *
 * @param param The parameter to get (SSH_IPARAM_)
 * @return Integer parameter value
 */
int ssh_get_iparam(int param) {
    switch(param) {
        case SSH_IPARAM_AFW:
            return ssh_afw;
        case SSH_IPARAM_XFW:
            return ssh_xfw;
        case SSH_IPARAM_PRP:
            return ssh_prp;
        case SSH_IPARAM_CMP:
            return ssh_cmp;
        case SSH_IPARAM_CAS:
            return ssh_cas;
        case SSH_IPARAM_SHH:
            return ssh_shh;
        case SSH_IPARAM_VER:
            return ssh_ver;
        case SSH_IPARAM_VRB:
            return ssh_vrb;
        case SSH_IPARAM_CHKIP:
            return ssh_chkip;
        case SSH_IPARAM_GWP:
            return ssh_gwp;
        case SSH_IPARAM_DYF:
            return ssh_dyf;
        case SSH_IPARAM_GSD:
            return ssh_gsd;
        case SSH_IPARAM_K4TGT:
            return ssh_k4tgt;
        case SSH_IPARAM_K5TGT:
            return ssh_k5tgt;
        case SSH_IPARAM_SHK:
            return ssh_shk;
        case SSH_IPARAM_2_ARK:
            return ssh2_ark;
        case SSH_IPARAM_CFG:
            return ssh_cfg;
        case SSH_IPARAM_GKX:
            return ssh_gkx;
        case SSH_IPARAM_K5_IS_K4:
            return ssh_k5_is_k4;
        case SSH_IPARAM_HBT:
            return ssh_hbt;
    }
    return 0;
}

/** Utility function for copying a string to a destination or freeing
 * the destination if the source is null
 *
 * @param dest destination
 * @param src new value
 */
static void copy_set_sparam(char **dest, const char* src) {
    if (*dest) {
        free(*dest);
        *dest = NULL;
    }
    if (src) {
        *dest = _strdup(src);
    }
}

/** Set a string parameter. Takes a copy of the supplied value.
 *
 * @param param Parameter to set (SSH_SPARAM_)
 * @param value New value for the parameter
 * @return
 */
int ssh_set_sparam(int param, const char* value) {
    switch(param) {
        case SSH_SPARAM_1_CIF:
            break;
        case SSH_SPARAM_2_CIF:
            copy_set_sparam(&ssh2_cif, value);
            break;
        case SSH_SPARAM_2_MAC:
            copy_set_sparam(&ssh2_mac, value);
            break;
        case SSH_SPARAM_2_AUTH:
            copy_set_sparam(&ssh2_auth, value);
            break;
        case SSH_SPARAM_2_HKA:
            copy_set_sparam(&ssh2_hka, value);
            break;
        case SSH_SPARAM_HST:
            copy_set_sparam(&ssh_hst, value);
            break;
        case SSH_SPARAM_PRT:
            copy_set_sparam(&ssh_prt, value);
            break;
        case SSH_SPARAM_CMD:
            copy_set_sparam(&ssh_cmd, value);
            break;
        case SSH_SPARAM_XAL:
            copy_set_sparam(&ssh_xal, value);
            break;
        case SSH_SPARAM_1_GNH:
            break;
        case SSH_SPARAM_1_UNH:
            break;
        case SSH_SPARAM_2_GNH:
            copy_set_sparam(&ssh2_gnh, value);
            break;
        case SSH_SPARAM_2_UNH:
            copy_set_sparam(&ssh2_unh, value);
            break;
        case SSH_SPARAM_2_KEX:
            copy_set_sparam(&ssh2_kex, value);
            break;
        case SSH_SPARAM_PXC:
            copy_set_sparam(&ssh_pxc, value);
            break;
        case SSH_SPARAM_DIR:
            copy_set_sparam(&ssh_dir, value);
            break;
        default:
            return 1;
    }
    return 0;
}

/** Get String parameter
 *
 * @param param Parameter to get (SSH_SPARAM_)
 * @return The string parameter
 */
const char* ssh_get_sparam(int param) {
    switch(param) {
        case SSH_SPARAM_1_CIF:
            return NULL;
        case SSH_SPARAM_2_CIF:
            return ssh2_cif;
        case SSH_SPARAM_2_MAC:
            return ssh2_mac;
        case SSH_SPARAM_2_AUTH:
            return ssh2_auth;
        case SSH_SPARAM_2_HKA:
            return ssh2_hka;
        case SSH_SPARAM_HST:
            return ssh_hst;
        case SSH_SPARAM_PRT:
            return ssh_prt;
        case SSH_SPARAM_CMD:
            return ssh_cmd;
        case SSH_SPARAM_XAL:
            return ssh_xal;
        case SSH_SPARAM_1_GNH:
            return NULL;
        case SSH_SPARAM_1_UNH:
            return NULL;
        case SSH_SPARAM_2_GNH:
            return ssh2_gnh;
        case SSH_SPARAM_2_UNH:
            return ssh2_unh;
        case SSH_SPARAM_2_KEX:
            return ssh2_kex;
        case SSH_SPARAM_PXC:
            return ssh_pxc;
        case SSH_SPARAM_DIR:
            return ssh_dir;
        default:
            return NULL;
    }
    return NULL;
}

/** Set the list of SSH identity files to use for authentication
 *
 * @param identity_files List of identity files, null terminated.
 * @returns 0 on success, -1 if not supported
 */
int ssh_set_identity_files(const char** identity_files) {
    return -1;
}

/** Get the socket currently in use by the SSH client.
 *
 * @returns Socket for the current SSH connection, or -1 if not implemented or
 *      no active connection
 */
int ssh_get_socket(void) {

    /* If there is an active SSH session, this function should return its
     * socket. It's used by the various "set tcp" commands to set socket
     * options.
     *
     * If there is no active connection, or the SSH client can't supply
     * the socket its using, return -1
     */

    return -1;
}

/** This is the equivalent of ssh_dll_init - when the SSH module is
 * compiled into the K95 executable (SSH_DLL not defined), this is
 * called on application startup to give the SSH subsystem an
 * opportunity to set sensible defaults, etc.
 */
void ssh_initialise(void) {

}

/* This a message we'll output to Kermit 95 if the user tries to make a
 * connection using this null SSH backend
 */
static char* message =
"This is the null SSH backend. It serves two purposes:\r\n"
"  1. To allow testing Kermit 95s ability to load SSH DLLs in the absence\r\n"
"     of a real SSH backend DLL to test against (such as on Windows or OS/2\r\n"
"     versions where no backend is available)\r\n"
"  2. To provide a template for the development of alternative SSH \r\n"
"     backends for Kermit 95\r\n"
"\n\n"
"Aside from producing this message, the null SSH backend does nothing.\r\n"
"You may now return to the command screen using the exit sequence (Alt+x\r\n"
"by default).\0";

/* How long the message is, and what the next character to return to K95 is */
static int message_length = 0, message_position = 0;

/** Opens an SSH connection. Connection parameters are passed through global
 * variables
 *
 * @return An error code (0 = success)
 */
int ssh_open(void){
    /* Reset the message to the start */
    message_length = strlen(message);
    message_position = 0;

    /*
     * If Kermit 95 is configured with proxy server details
     * ("set tcp http-proxy" or "set tcp socks-proxy"), then Kermit 95 can
     * open a connection through that proxy server and hand that connection
     * over ready to make an SSH connection through.
     *
     * To do this, just call ssh_open_socket(). If you get a socket back,
     * you're free to go ahead and use it. If you get INVALID_SOCKET back
     * then you'll need to make the connection yourself.
     *
     * If ssh_open_socket() returns a valid socket then you are responsible
     * for closing it when the SSH connection is closed (or fails to open).
     * Kermit 95 doesn't track it and won't close it for you.
     */

    return 0;
}

/** Closes any existing SSH Session.
 *
 * @return  0 on success, < 0 on failure.
 */
int ssh_clos(void) {
    return 0;
}

/** Network I/O Check. This function is polled by K95 to get the status
 * of the connection and find out how many bytes are waiting to be
 * processed. It is called frequently so must return quickly.
 *
 * @return >= 0 indicates number of bytes waiting to be read
 *          < 0 indicates a fatal error and the connection should be closed.
 */
int ssh_tchk(void) {
    /* Respond with how many characters are left in the message */
    return message_length - message_position;
}

/** Flush input
 *
 * @return 0 on success, < 0 on error
 */
int ssh_flui(void) {
    return 0;
}

/** Network Break - send a break signal to the remote process.
 * This may or may not do anything. Supported on SSH V2 only.
 *
 * @return
 */
int ssh_break(void) {
    return 0;
}

/** Input Character. Reads one character from the input queue
 *
 * @param timeout 0 for none (block until there is a character to read),
 *                positive for seconds, negative for milliseconds
 * @return -1 for timeout, >= 0 is a valid character, < -1 is a fatal error
 */
int ssh_inc(int timeout) {
    int result;

    if (message_position >= message_length) {
        /* We're at the end of the message and there is nothing more to
         * return. If K95 wants us to block until another byte arrives
         * (which it will never do), just sleep for a while to not waste
         * CPU */
        int tmo = timeout;
        if (tmo == 0) tmo = 1000;
#ifdef NT
        Sleep(1000);
#else
        DosSleep(1000);
#endif
        return -1;
    };

    /* Return the next character in the message */
    result = message[message_position];
    message_position++;
    return result;
}

/** Extended Input - reads multiple characters from the network. This
 * will never be called requesting more characters than previously
 * reported as available by ssh_tchk(). We aren't required to return
 * the number of characters requested but we must not return more (this
 * is the size of the buffer allocated)
 *
 * @param count Maximum number of characters to be read
 * @param buffer Buffer (of length count) to read characters into
 * @return >= 0 indicates the number of characters read, < 0 indicates error
 */
int ssh_xin(int count, char * buffer) {
    int length = message_length - message_position;

    if (count < length) length = count;

    /* We're at the end of the message - nothing more to return */
    if (length <= 0) return 0;

    /* Return the requested portion of the message */
    memcpy(buffer, message, length);
    message_position += length;

    return length;
}

/** Terminal Output Character - send a single character. Blocks until the
 * character has been handled.
 *
 * @param c character to send
 * @return 0 for success, <0 for error
 */
int ssh_toc(int c) {
    return 0;
}

/** Terminal Output Line - send multiple characters.
 *
 * @param buffer characters to be sent
 * @param count number of characters to be sent
 * @return  >= 0 for number of characters sent, <0 for a fatal error.
 */
int ssh_tol(char * buffer, int count) {
    return 0;
}

/** Negotiate About Window Size. Let the remote host know the window dimensions
 * and terminal type if these have changed.
 *
 */
int ssh_snaws(void) {
    return 0;
}

/** Add a new Reverse (remote) port forward for future connections. This is
 * called by the following commands:
 *    SSH ADD REMOTE-PORT-FORWARD
 *    SSH FORWARD-REMOTE-PORT
 *
 * @param address Address the remote SSH server should listen on (reserved for
 *          future use)
 * @param port Port the remote SSH server will listen on
 * @param host Host connetions will be made to (on the client side)
 * @param host_port Port connections will be made to (on the client side)
 * @param apply Add the forwarding to any active SSH session
 * @returns 0 on success
 */
int ssh_fwd_remote_port(char* address, int port, char * host, int host_port, BOOL apply)
{
    return 0;
}

/** Add a new Direct (local) port forward for future connections. This is
 * called by the following commands:
 *    SSH ADD LOCAL-PORT-FORWARD
 *    SSH FORWARD-LOCAL-PORT
 *
 * @param address Address the remote SSH server should listen on (reserved for
 *          future use)
 * @param port Port K95 will listen on for new connections
 * @param host Host connetions will be made to from the server
 * @param host_port port connections will be made to from the server
 * @param apply Add the new forwarding to any active SSH session
 * @returns 0 on success
 */
int ssh_fwd_local_port(char* address, int port, char * host, int host_port, BOOL apply) {
    return 0;
}

/** Clears all remote port forwards for future SSH sessions
 *
 * @param apply Also stop forwarding all remote ports in any active SSH session
 * @returns 0 on success
 */
int ssh_fwd_clear_remote_ports(BOOL apply) {

    return 0;
}

/** Clears all local port forwards for future SSH sessions
 *
 * @param apply Also stop forwarding all  ports in any active SSH session
 * @returns 0 on success
 */
int ssh_fwd_clear_local_ports(BOOL apply) {

    return 0;
}

/** Remove a single reverse/remote port forward.
 *
 * @param port Reverse port forward to remove
 * @param apply Also remove the port forward from any active session. Does not
 *      close any established connections.
 * @return 0 on success
 */
int ssh_fwd_remove_remote_port(int port, BOOL apply);

/** Remove a single direct/local port forward.
 *
 * @param port Direct port forward to remove
 * @param apply Also remove the port forward from any active session. Does not
 *      close any established connections.
 * @return 0 on success
 */
int ssh_fwd_remove_local_port(int port, BOOL apply);

/** Gets all forwarded ports. The final entry in the list has a type of
 * SSH_PORT_FORWARD_NULL.
 *
 * @returns List of forwarded ports, or NULL on error or empty list
 */
const ssh_port_forward_t* ssh_fwd_get_ports(void) {
    return NULL;
}

/** Creates an SSH key pair
 *
 * @param filename File to write the private key to
 * @param bits Length of the key in bits. Valid options vary by key type
 * @param pp Passphrase
 * @param type Key type
 * @param cmd_comment SSH V1 RSA Comment (obsolete)
 * @return
 */
int sshkey_create(char * filename, int bits, char *pp, int type,
                  char *cmd_comment) {
    return 0;
}

/** Displays the fingerprint for the specified public key
 *
 * @param filename Key file to display the fingerprint for. If not supplied, one
 *                 will be prompted for
 * @param babble 0 - fingerprint, 1 - IETF (ignored)
 * @return 0
 */
int sshkey_display_fingerprint(char * filename, int babble) {
    return 0;
}

/** Outputs the public key for the specified private key - same as what you'd
 * put in authorized_keys.
 * @param filename key file - will be prompted if not specified
 * @param passphrase key passphrase - will be prompted if not specified
 */
int sshkey_display_public(char * filename, char *identity_passphrase) {
    return 0;
}

/** Like sshkey_display_public but puts some extra cruft around the output.
 *
 * @param filename key file - will be prompted if not specified
 * @param identity_passphrase key passphrase - will be prompted if not specified
 */
int sshkey_display_public_as_ssh2(char * filename,char *identity_passphrase) {
    return 0;
}

int sshkey_change_passphrase(char * filename, char * oldpp, char * newpp) {
    return 0;
}

#ifdef SSHTEST
int sshkey_v1_change_comment(char * filename, char * comment, char * pp) {
    return 0;
}
#endif /* SSHTEST */

#ifdef COMMENT
char * sshkey_default_file(int a) {
    return NULL; /* TODO */
}
#endif /* COMMENT */

/** Manually re-key the SSH connection
 */
void ssh_v2_rekey(void) {

}

/** Return the current protocol version.
 *
 * @return Current protocol version (eg, "SSH-2.0")
 */
const char * ssh_proto_ver(void) {
    return NULL;
}

/** Return the current SSH implementation version, which may be different from
 * the SSH backend version (ssh_dll_ver())
 *
 * @return SSH implementation version
 */
const char * ssh_impl_ver(void) {
    return "Null SSH";
}

int ssh_agent_delete_file(const char *filename) {
    return 0;
}

int ssh_agent_delete_all(void) {
    return 0;
}

int ssh_agent_add_file (const char *filename) {
    return 0;
}

int ssh_agent_list_identities(int do_fp) {
    return 0;
}

/** Called by Kermit 95 before the DLL is unloaded. This is only called if
 * ssh_dll_init was previously called. It is not called on application exit.
 *
 * The normal reason for ssh_unload() to be called is that Kermit 95 has
 * decided the DLL is unsuitable/incompatible in some way or because
 * ssh_dll_init() returned an error code.
 *
 * @return
 */
void ssh_unload(void) {

}

/** Returns version information for this SSH backend DLL which may be different
 * from the SSH Implementation version (ssh_impl_ver()).
 *
 * @return
 */
const char * ssh_dll_ver(void) {
    return "NULL SSH Subsystem (does nothing)";
}

/** Gets the specified keyword table.
 *
 * @param keytab_id keyword table to get
 * @return the requested keyword table
 */
ktab_ret ssh_get_keytab(int keytab_id) {
    ktab_ret ret;
    ret.rc = 0;

    switch(keytab_id) {
        case SSH_KTAB_V2_AUT: {
            ret.ktab = ssh2aut;
            ret.ktab_len = nssh2aut;
            break;
        }
        case SSH_KTAB_V2_CIPHERS: {
            ret.ktab = ssh2ciphers;
            ret.ktab_len = nssh2ciphers;
            break;
        }
        case SSH_KTAB_V2_MACS: {
            ret.ktab = ssh2macs;
            ret.ktab_len = nssh2macs;
            break;
        }
        case SSH_KTAB_HKA: {
            ret.ktab = hkatab;
            ret.ktab_len = nhkatab;
            break;
        }
        case SSH_KTAB_KEX: {
            ret.ktab = sshkextab;
            ret.ktab_len = nsshkextab;
            break;
        }
        case SSH_KTAB_V1_CIPHERS: {
            ret.ktab = ssh1ciphers;
            ret.ktab_len = nssh1ciphers;
            break;
        }
        default: {
            ret.rc = -1;
        }
    }
    return ret;
}

/** Returns TRUE if the specified feature is supported by the SSH backend,
 * or FALSE if it is not. This is used to enable or disable various "ssh" and
 * "set ssh" commands and options.
 *
 * @param feature_id The feature being checked
 * @return TRUE if the feature is supported, or FALSE if it is not
 */
int ssh_feature_supported(int feature_id) {
    switch(feature_id) {
        case SSH_FEAT_OPENSSH_CONF:     /* Configuration via openssh config file */
        case SSH_FEAT_KEY_MGMT:         /* SSH key creation, etc */
        case SSH_FEAT_REKEY_AUTO:       /* Automatic rekeying options */
        case SSH_FEAT_SSH_V1:           /* SSHv1 protocol support */
        case SSH_FEAT_PROXY_CMD:        /* Proxy command */
        case SSH_FEAT_ADV_KERBEROS4:    /* Advanced Kerberos IV options */
        case SSH_FEAT_ADV_KERBEROS5:    /* Advanced Kerberos V options */
        case SSH_FEAT_REKEY_MANUAL:     /* Manual rekeying */
        case SSH_FEAT_FROM_PRIV_PRT:    /* Connect from private port */
        case SSH_FEAT_GSSAPI_KEYEX:     /* GSSAPI Key Exchange */
        case SSH_FEAT_PORT_FWD:         /* Local and remote port forwarding */
        case SSH_FEAT_X11_FWD:          /* X11 forwarding */
        case SSH_FEAT_AGENT_FWD:        /* SSH Agent Forwarding */
        case SSH_FEAT_GSSAPI_DELEGAT:   /* GSSAPI Delegation */
        case SSH_FEAT_AGENT_MGMT:       /* SSH Agent management */
        case SSH_FEAT_DYN_PORT_FWD:     /* Dynamic port forwarding */
        default:
            return TRUE;
    }
}

/** This function should return the text for "HELP SET SSH". Any commands not
 * supported should be excluded.
 *
 * @return Help text for HELP SET SSH.
 */
const char** ssh_get_set_help(void) {

    /*
     * TODO: Remove help text for any commands reported as not supported by
     *  ssh_feature_supported(), and adjust the parameter lists to match
     *  those returned by ssh_get_keytab()
     */

    static const char *hmxyssh[] = {
/* Feature: SSH_FEAT_AGENT_FWD */
"SET SSH AGENT-FORWARDING { ON, OFF }",
"  If an authentication agent is in use, setting this value to ON",
"  results in the connection to the agent being forwarded to the remote",
"  computer.  The default is OFF.",
" ",
"SET SSH CHECK-HOST-IP { ON, OFF }",
"  Specifies whether the remote host's ip-address should be checked",
"  against the matching host key in the known_hosts file.  This can be",
"  used to determine if the host key changed as a result of DNS spoofing.",
"  The default is ON.",
" ",
"SET SSH COMPRESSION { ON, OFF }",
"  Specifies whether compression will be used.  The default is ON.",
" ",
"SET SSH DIRECTORY directory",
"  Specifies where Kermit 95 should look for the default SSH user files",
"  such as the user-known-hosts file and identity files (id_rsa, etc).",
"  By default Kermit 95 looks for these in \\v(appdata)ssh.",
" ",
/* Feature: SSH_FEAT_DYN_PORT_FWD */
"SET SSH DYNAMIC-FORWARDING { ON, OFF }",
"  Specifies whether Kermit is to act as a SOCKS4 service on port 1080",
"  when connected to a remote host via SSH.  When Kermit acts as a SOCKS4",
"  service, it accepts connection requests and forwards the connections",
"  through the remote host.  The default is OFF.",
" ",
/* Feature: SSH_FEAT_PORT_FWD */
"SET SSH GATEWAY-PORTS { ON, OFF }",
"  Specifies whether Kermit should act as a gateway for forwarded",
"  connections received from the remote host.  The default is OFF.",
" ",
/* Feature: SSH_FEAT_GSSAPI_DELEGAT */
"SET SSH GSSAPI DELEGATE-CREDENTIALS { ON, OFF }",
"  Specifies whether Kermit should delegate GSSAPI credentials to ",
"  the remote host after authentication.  Delegating credentials allows",
"  the credentials to be used from the remote host.  The default is OFF.",
" ",
"SET SSH HEARTBEAT-INTERVAL <seconds>",
"  Specifies a number of seconds of idle time after which an IGNORE",
"  message will be sent to the server.  This pulse is useful for",
"  maintaining connections through HTTP Proxy servers and Network",
"  Address Translators.  The default is OFF (0 seconds).",
" ",
"SET SSH IDENTITY-FILE filename [ filename [ ... ] ]",
"  Specifies one or more files from which the user's authorization",
"  identities (private keys) are to be read when using public key",
"  authorization.  These are files used in addition to the default files:",
" ",
"    \\v(appdata)ssh/identity      V1 RSA",     /* Feature: SSH_FEAT_SSH_V1 */
"    \\v(appdata)ssh/id_rsa        V2 RSA",
"    \\v(appdata)ssh/id_dsa        V2 DSA",
"    \\v(appdata)ssh/id_ecdsa      ECDSA",
"    \\v(appdata)ssh/id_ed25519    ED25519",
" ",
/* Feature: SSH_FEAT_ADV_KERBEROS4 */
"SET SSH KERBEROS4 TGT-PASSING { ON, OFF }",
"  Specifies whether Kermit should forward Kerberos 4 TGTs to the host.",
"  The default is OFF.",
" ",
/* Feature: SSH_FEAT_ADV_KERBEROS5 */
"SET SSH KERBEROS5 TGT-PASSING { ON, OFF }",
"  Specifies whether Kermit should forward Kerberos 5 TGTs to to the",
"  host.  The default is OFF.",
" ",
/* Feature: SSH_FEAT_FROM_PRIV_PRT */
"SET SSH PRIVILEGED-PORT { ON, OFF }",
"  Specifies whether a privileged port (less than 1024) should be used",
"  when connecting to the host.  Privileged ports are not required except",
"  when using SSH V1 with Rhosts or RhostsRSA authorization.  The default",
"  is OFF.",
" ",
/* Feature: SSH_FEAT_PROXY_CMD */
"SET SSH PROXY-COMMAND [ command ]",
"  Specifies the command to be executed in order to connect to the remote",
"  host. ",
" ",
"SET SSH QUIET { ON, OFF }",
"  Specifies whether all messages generated in conjunction with SSH",
"  protocols should be suppressed.  The default is OFF.",
" ",
"SET SSH STRICT-HOST-KEY-CHECK { ASK, ON, OFF }",
"  Specifies how Kermit should behave if the the host key check fails.",
"  When strict host key checking is OFF, the new host key is added to the",
"  protocol-version-specific user-known-hosts-file.  When strict host key",
"  checking is ON, the new host key is refused and the connection is",
"  dropped.  When set to ASK, Kermit prompt you to say whether the new",
"  host key should be accepted.  The default is ASK.",
" ",
"  Strict host key checking protects you against Trojan horse attacks.",
"  It depends on you to maintain the contents of the known-hosts-file",
"  with current and trusted host keys.",
" ",
/* Feature: SSH_FEAT_OPENSSH_CONF */
"SET SSH USE-OPENSSH-CONFIG { ON, OFF }",
"  Specifies whether Kermit should parse an OpenSSH configuration file",
"  after applying Kermit's SET SSH commands.  The configuration file",
"  would be located at \\v(home)ssh/ssh_config.  The default is OFF.",
" ",
/* Feature: SSH_FEAT_SSH_V1 */
"SET SSH V1 CIPHER { 3DES, BLOWFISH, DES }",
"  Specifies which cipher should be used to protect SSH version 1",
"  connections.  The default is 3DES.",
" ",
/* Feature: SSH_FEAT_SSH_V1 */
"SET SSH V1 GLOBAL-KNOWN-HOSTS-FILE filename",
"  Specifies the location of the system-wide known-hosts file.  The",
"  default is:",
" ",
"    \v(common)ssh_known_hosts",
" ",
/* Feature: SSH_FEAT_SSH_V1 */
"SET SSH V1 USER-KNOWN-HOSTS-FILE filename",
"  Specifies the location of the user-known-hosts-file.  The default",
"  location is:",
" ",
"    \\v(appdata)ssh/known_hosts",
" ",
"SET SSH V2 AUTHENTICATION { GSSAPI, KEYBOARD-INTERACTIVE, PASSWORD, ",
"    PUBKEY, NONE } [ ... ]",
"  Specifies an ordered list of SSH version 2 authentication methods to",
"  be used when connecting to the remote host. The SSH client requires ",
"  none to be attempted first, so the default list is:",
" ",
"    none gssapi publickey keyboard-interactive password",
" ",
/* Feature: SSH_FEAT_REKEY_AUTO */
"SET SSH V2 AUTO-REKEY { ON, OFF }",
"  Specifies whether Kermit automatically issues rekeying requests",
"  once an hour when SSH version 2 in in use.  The default is ON.",
" ",
"SET SSH V2 CIPHERS { 3DES-CBC, AES128-CBC, AES192-CBC, AES256-CBC, ",
"     AES128-CTR, AES192-CTR, AES256-CTR, AES128-GCM@OPENSSH.COM, ",
"     AES256-GCM@OPENSSH.COM, CHACHAE20-POLY1305 }",
"  Specifies an ordered list of SSH version ciphers to be used to encrypt",
"  the established connection.  The default list is:",
" ",
"    aes256-gcm@openssh.com aes128-gcm@openssh.com aes256-ctr aes192-ctr",
"    aes128-ctr aes256-cbc aes192-cbc aes128-cbc 3des-cbc",
" ",
"SET SSH V2 GLOBAL-KNOWN-HOSTS-FILE filename",
"  Specifies the location of the system-wide known-hosts file.  The default",
"  location is:",
" ",
"    \\v(common)ssh/known_hosts2",
" ",
"SET SSH V2 HOSTKEY-ALGORITHMS { ECDSA-SHA2-NISTP256, ECDSA-SHA2-NISTP384, ",
"     ECDSA-SHA2-NISTP521, RSA-SHA2-256, RSA-SHA2-512, SSH-DSS, SSH-ED25519, ",
"     SSH-RSA }",
"  Specifies an ordered list of hostkey algorithms to be used to verify",
"  the identity of the host.  The default list is",
" ",
"    ssh-ed25519 ecdsa-sha2-nistp521 ecdsa-sha2-nistp384 ecdsa-sha2-nistp256",
"    rsa-sha2-512 rsa-sha2-256 ssh-rsa",
" ",
"SET SSH V2 KEY-EXCHANGE-METHODS { CURVE25519-SHA256, ",
"     CURVE25519-SHA256@LIBSSH.ORG, DIFFIE-HELLMAN-GROUP1-SHA1, ",
"     DIFFIE-HELLMAN-GROUP14-SHA1, DIFFIE-HELLMAN-GROUP14-SHA256, ",
"     DIFFIE-HELLMAN-GROUP16-SHA512, DIFFIE-HELLMAN-GROUP18-SHA512, ",
"     DIFFIE-HELLMAN-GROUP-EXCHANGE-SHA1, ",
"     DIFFIE-HELLMAN-GROUP-EXCHANGE-SHA256, ECDH-SHA2-NISTP256, ",
"     ECDH-SHA2-NISTP384, ECDH-SHA2-NISTP521 }",
"  Specifies an ordered list of Key Exchange Methods to be used to generate ",
"  per-connection keys. The default list is:",
" ",
"    curve25519-sha256 curve25519-sha256@libssh.org ecdh-sha2-nistp256 ",
"    ecdh-sha2-nistp384 ecdh-sha2-nistp521 diffie-hellman-group18-sha512",
"    diffie-hellman-group16-sha512 diffie-hellman-group-exchange-sha256",
"    diffie-hellman-group14-sha256 diffie-hellman-group14-sha1 ",
"    diffie-hellman-group1-sha1 ext-info-c",
" ",
"SET SSH V2 MACS { HMAC-SHA1, HMAC-SHA1-ETM@OPENSSH.COM, HMAC-SHA2-256, ",
"     HMAC-SHA2-256-ETM@OPENSSH.COM, HMAC-SHA2-512, ",
"     HMAC-SHA2-512-ETM@OPENSSH.COM, NONE }",
"  Specifies an ordered list of Message Authentication Code algorithms to",
"  be used for integrity  protection of the established connection.  The",
"  default list is:",
" ",
"    hmac-sha2-256-etm@openssh.com hmac-sha2-512-etm@openssh.com ",
"    hmac-sha1-etm@openssh.com hmac-sha2-256 hmac-sha2-512 hmac-sha1",
" ",
"SET SSH V2 USER-KNOWN-HOSTS-FILE filename",
"  Specifies the location of the user-known-hosts file.  The default",
"  location is:",
" ",
"    \\v(appdata)ssh/known_hosts2",
" ",
"SET SSH VERBOSE level",
"  Specifies how many messages should be generated by the OpenSSH engine.",
"  The level can range from 0 to 7.  The default value is 2.",
" ",
/* Feature: SSH_FEAT_SSH_V1 */
"SET SSH VERSION { 1, 2, AUTOMATIC }",
"   Specifies which SSH version should be negotiated.  The default is",
"   AUTOMATIC which means use version 2 if supported; otherwise to fall",
"   back to version 1.",
" ",
/* Feature: SSH_FEAT_X11_FWD */
"SET SSH X11-FORWARDING { ON, OFF }",
"  Specifies whether X Windows System Data is to be forwarded across the",
"  established SSH connection.  The default is OFF.  When ON, the DISPLAY",
"  value is set using the SET TELNET ENV DISPLAY command.",
" ",
/* Feature: SSH_FEAT_X11_XAUTH */
"SET SSH XAUTH-LOCATION filename",
"  Specifies the location of the xauth executable (if provided with the",
"  X11 Server software.)",
/* Last line of help text must be an empty string to terminate */
""
    };

    return hmxyssh;
}

/** This function should return the text for "HELP SSH". Any commands not
 * supported should be excluded.
 *
 * @return Help text for HELP SSH.
 */
const char** ssh_get_help(void) {

    /*
     * TODO: Remove help text for any commands reported as not supported by
     *  ssh_feature_supported(), and adjust the parameter lists to match
     *  those returned by ssh_get_keytab()
     */

    static const char * hmxxssh[] = {
"Syntax: SSH { ADD, AGENT, CLEAR, KEY, [ OPEN ], V2 } operands...",
"  Performs an SSH-related action, depending on the keyword that follows:",
" ",
/* Feature: SSH_FEAT_PORT_FWD */
"SSH ADD LOCAL-PORT-FORWARD local-port host port",
"  Adds a port forwarding triplet to the local port forwarding list.",
"  The triplet specifies a local port to be forwarded and the hostname /",
"  ip-address and port number to which the port should be forwarded from",
"  the remote host.  Port forwarding is activated at connection",
"  establishment and continues until the connection is terminated.",
" ",
/* Feature: SSH_FEAT_PORT_FWD */
"SSH ADD REMOTE-PORT-FORWARD remote-port host port",
"  Adds a port forwarding triplet to the remote port forwarding list.",
"  The triplet specifies a remote port to be forwarded and the",
"  hostname/ip-address and port number to which the port should be",
"  forwarded from the local machine.  Port forwarding is activated at",
"  connection establishment and continues until the connection is",
"  terminated.",
" ",
/* Feature: SSH_FEAT_AGENT_MGMT */
"SSH AGENT ADD [ identity-file ]",
"  Adds the contents of the identity-file (if any) to the SSH AGENT",
"  private key cache.  If no identity-file is specified, all files",
"  specified with SET SSH IDENTITY-FILE are added to the cache.",
" ",
/* Feature: SSH_FEAT_AGENT_MGMT */
"SSH AGENT DELETE [ identity-file ]",
"  Deletes the contents of the identity-file (if any) from the SSH AGENT",
"  private key cache.  If no identity-file is specified, all files",
"  specified with SET SSH IDENTITY-FILE are deleted from the cache.",
" ",
/* Feature: SSH_FEAT_AGENT_MGMT */
"SSH AGENT LIST [ /FINGERPRINT ]",
"  Lists the contents of the SSH AGENT private key cache.  If /FINGERPRINT",
"  is specified, the fingerprint of the private keys are displayed instead",
"  of the keys.",
" ",
/* Feature: SSH_FEAT_PORT_FWD */
"SSH CLEAR LOCAL-PORT-FORWARD",
"  Clears the local port forwarding list.",
" ",
/* Feature: SSH_FEAT_PORT_FWD */
"SSH CLEAR REMOTE-PORT-FORWARD",
"  Clears the remote port forwarding list.",
" ",
/* Feature: SSH_FEAT_KEY_MGMT */
"SSH KEY commands:",
"  The SSH KEY commands create and manage public and private key pairs",
"  (identities).  There are four forms of SSH keys.  Each key pair is",
"  stored in its own set of files:",
" ",
"   Key Type      Private Key File           Public Key File",
"    RSA keys      \\v(home).ssh/id_rsa       \\v(home).ssh/id_rsa.pub",
"    DSA keys      \\v(home).ssh/id_dsa       \\v(home).ssh/id_dsa.pub",
"    ECDSA keys    \\v(home).ssh/id_ecdsa     \\v(home).ssh/id_ecdsa.pub",
"    ED25519 keys  \\v(home).ssh/id_ed25519   \\v(home).ssh/id_ed25519.pub",
" ",
"  Keys are stored using the OpenSSH keyfile format.  The private key",
"  files can be (optionally) protected by specifying a passphrase.  A",
"  passphrase is a longer version of a password.  English text provides",
"  no more than 2 bits of key data per character.  56-bit keys can be",
"  broken by a brute force attack in approximately 24 hours.  When used,",
"  private key files should therefore be protected by a passphrase of at",
"  least 40 characters (about 80 bits).",
" ",
"  To install a public key file on the host, you must transfer the file",
"  to the host and append it to your \"authorized_keys\" file.  The file",
"  permissions must be 600 (or equivalent).",
" ",
/* Feature: SSH_FEAT_KEY_MGMT */
"SSH KEY CHANGE-PASSPHRASE [ /NEW-PASSPHRASE:passphrase",
"      /OLD-PASSPHRASE:passphrase ] filename",
"  This re-encrypts the specified private key file with a new passphrase.",
"  The old passphrase is required.  If the passphrases (and filename) are",
"  not provided Kermit prompts your for them.",
" ",
/* Feature: SSH_FEAT_KEY_MGMT */
"SSH KEY CREATE [ /BITS:bits /PASSPHRASE:passphrase",
"    /TYPE:{ DSS, ECDSA, ED25519, RSA } ] filename",
"  This command creates a new private/public key pair.  The defaults is",
"  TYPE:ED25519.  The filename is the name of the private key file.  The",
"  The public key is created with the same name with .pub appended to it.",
"  If a filename is not specified Kermit prompts you for it. Key length ",
"  options (/BITS:) depends on the key type:",
" ",
"    ECDSA: 256 (default), 384, 521",
"    RSA: 1024, 2048, 3072 (default), 4096, 8192",
"    DSS: 1024 (default), 2048",
" ",
"  ED25519 does not support being given a key length and any value supplied",
"  via /BITS: will be ignored.",
" ",
/* Feature: SSH_FEAT_KEY_MGMT */
"SSH KEY DISPLAY [ /FORMAT:{FINGERPRINT,IETF,OPENSSH,SSH.COM} ] filename",
"  This command displays the contents of a public or private key file.",
"  The default format is OPENSSH.",
" ",
/* Feature: SSH_FEAT_SSH_V1 */
"SSH KEY V1 SET-COMMENT filename comment",
"  This command replaces the comment associated with a V1 RSA key file.",
" ",
"SSH [ OPEN ] host [ port ] [ /COMMAND:command /USER:username",
"      /PASSWORD:pwd /VERSION:{ 1, 2 } /X11-FORWARDING:{ ON, OFF } ]",
"  This command establishes a new connection using SSH version 1 or",
"  version 2 protocol.  The connection is made to the specified host on",
"  the SSH port (you can override the port by including a port name or",
"  number after the host name).  Once the connection is established the",
"  authentication negotiations begin.  If the authentication is accepted,",
"  the local and remote port forwarding lists are used to establish the",
"  desired connections.  If X11 Forwarding is active, this results in a",
"  remote port forwarding between the X11 clients on the remote host and",
"  X11 Server on the local machine.  If a /COMMAND is provided, the",
"  command is executed on the remote host in place of your default shell.",
" ",
"  An example of a /COMMAND to execute C-Kermit in SERVER mode is:",
"     SSH OPEN hostname /COMMAND:{kermit -x -l 0}",
" ",
/* Feature: SSH_FEAT_PORT_FWD */
"SSH REMOVE LOCAL-PORT-FORWARD local-port",
"  Removes the local port forward with the specified local-port from",
"  the local port forwarding list. This has no effect on any active ",
"  connection.",
" ",
/* Feature: SSH_FEAT_PORT_FWD */
"SSH REMOVE REMOTE-PORT-FORWARD remote-port",
"  Removes the remote port forward with the specified remote-port from",
"  the remote port forwarding list. This has no effect on any active ",
"  connection.",
" ",
/* Feature: SSH_FEAT_REKEY_MANUAL */
"SSH V2 REKEY",
"  Requests that an existing SSH V2 connection generate new session keys.",
/* Last line must be empty to terminate */
""
    };
    return hmxxssh;
}