ckuus3.c

KERMIT工具 这在办公室下载不了,很多人都没有载不到.

    "",         0,      0
};
static int nsetauth = sizeof(setauth)/sizeof(struct keytab) - 1;
#ifdef CK_KERBEROS
extern char * krb5_d_principal;         /* Default principal */
extern char * krb5_d_instance;
extern char * krb5_d_realm;             /* Default realm */
extern char * krb5_d_cc;                /* Default credentials cache */
extern char * krb5_d_srv;               /* Default service name */
extern int    krb5_d_lifetime;          /* Default lifetime */
extern int    krb5_d_forwardable;
extern int    krb5_d_proxiable;
extern int    krb5_d_renewable;
extern int    krb5_autoget;
extern int    krb5_autodel;
extern int    krb5_d_getk4;
extern int    krb5_checkaddrs;          /* Check TGT Addrs */
extern int    krb5_d_no_addresses;
extern char * krb5_d_addrs[];
extern char * k5_keytab;                /* Keytab file */

extern struct krb4_init_data krb4_init;
extern char * krb4_d_principal;         /* Default principal */
extern char * krb4_d_realm;             /* Default realm */
extern char * krb4_d_srv;               /* Default service name */
extern int    krb4_d_lifetime;          /* Default lifetime */
extern int    krb4_d_preauth;
extern char * krb4_d_instance;
extern int    krb4_autoget;
extern int    krb4_autodel;
extern int    krb4_checkaddrs;          /* Check TGT Addrs */
extern char * k4_keytab;                /* Keytab file */
#ifdef KRB4
extern int    k4debug;
#endif /* KRB4 */
static struct keytab krbver[] = {
    "4",                 4, 0,
    "5",                 5, 0,
    "iv",                4, CM_INV,
    "v",                 5, CM_INV
};
static int nkrbver = sizeof(krbver)/sizeof(struct keytab);

static struct keytab kdestab[] = {
    "never",            KRB_DEL_NO, 0,
    "no",               KRB_DEL_NO, CM_INV,
    "on-close",         KRB_DEL_CL, 0,
    "on-exit",          KRB_DEL_EX, 0
};
static int nkdestab = sizeof(kdestab)/sizeof(struct keytab);

static struct keytab k4tab[] = {
    "autodel",           XYKRBDEL, CM_INV,
    "autodestroy",       XYKRBDEL, 0,
    "autoget",           XYKRBGET, 0,
    "check-address",     XYKRBADR, 0,
    "debug",             XYKRBDBG, CM_INV,
    "instance",          XYKRBINS, 0,
    "keytab",            XYKRBKTB, 0,
    "lifetime",          XYKRBLIF, 0,
    "preauth",           XYKRBPRE, 0,
    "principal",         XYKRBPR,  0,
    "prompt",            XYKRBPRM, 0,
    "realm",             XYKRBRL,  0,
    "service-name",      XYKRBSRV, 0
};
static int nk4tab = sizeof(k4tab)/sizeof(struct keytab);

static struct keytab k5tab[] = {
    "addresses",         XYKRBADD, 0,
    "autodelete",        XYKRBDEL, CM_INV,
    "autodestroy",       XYKRBDEL, 0,
    "autoget",           XYKRBGET, 0,
    "cc",                XYKRBCC,  CM_INV,
    "check-address",     XYKRBADR, 0,
    "credentials-cache", XYKRBCC,  0,
    "forwardable",       XYKRBFWD, 0,
    "get-k4-tgt",        XYKRBK5K4,0,
    "instance",          XYKRBINS, 0,
    "keytab",            XYKRBKTB, 0,
    "lifetime",          XYKRBLIF, 0,
    "no-addresses",      XYKRBNAD, 0,
    "principal",         XYKRBPR,  0,
    "prompt",            XYKRBPRM, 0,
    "proxiable",         XYKRBPRX, 0,
    "realm",             XYKRBRL,  0,
    "renewable",         XYKRBRNW, 0,
    "service-name",      XYKRBSRV, 0
};
static int nk5tab = sizeof(k5tab)/sizeof(struct keytab);

#define KRB_PW_PRM 1
#define KRB_PR_PRM 2

static struct keytab krbprmtab[] = {
    "password",  KRB_PW_PRM, 0,
    "principal", KRB_PR_PRM, 0
};

#endif /* CK_KERBEROS */
#ifdef CK_SRP
static struct keytab srptab[] = {
    "prompt",            XYSRPPRM, 0
};
static int nsrptab = sizeof(srptab)/sizeof(struct keytab);
#define SRP_PW_PRM 1

static struct keytab srpprmtab[] = {
    "password",  SRP_PW_PRM, 0
};
#endif /* CK_SRP */
#ifdef CK_SSL
static struct keytab ssltab[] = {
    "certs-ok",          XYSSLCOK,  CM_INV,
    "cipher-list",       XYSSLCL,   0,
    "crl-dir",           XYSSLCRLD, 0,
    "crl-file",          XYSSLCRL,  0,
    "debug",             XYSSLDBG,  0,
    "dh-key-file",       XYSSLDKFL, CM_INV,
    "dh-param-file",     XYSSLDPFL, 0,
    "dsa-cert-chain-file", XYSSLDCCF, 0,
    "dsa-cert-file",     XYSSLDCFL, 0,
    "dsa-key-file",      XYSSLDKFL, 0,
    "dummy",             XYSSLDUM,  CM_INV,
    "only",              XYSSLON,   CM_INV,
    "random-file",       XYSSLRND,  0,
    "rsa-cert-chain-file", XYSSLRCCF, 0,
    "rsa-cert-file",     XYSSLRCFL, 0,
    "rsa-key-file",      XYSSLRKFL, 0,
    "verbose",           XYSSLVRB,  0,
    "verify",            XYSSLVRF,  0,
    "verify-dir",        XYSSLVRFD, 0,
    "verify-file",       XYSSLVRFF, 0
};
static int nssltab = sizeof(ssltab)/sizeof(struct keytab);
static struct keytab sslvertab[] = {
    "fail-if-no-peer-cert", SSL_VERIFY_PEER |
                            SSL_VERIFY_FAIL_IF_NO_PEER_CERT, 0,
    "no",               SSL_VERIFY_NONE, 0,
    "none",             SSL_VERIFY_NONE, CM_INV,
    "off",              SSL_VERIFY_NONE, CM_INV,
    "on",               SSL_VERIFY_PEER, CM_INV,
    "peer-cert",        SSL_VERIFY_PEER, 0
};
static int nsslvertab = sizeof(sslvertab)/sizeof(struct keytab);
#endif /* CK_SSL */
#endif /* CK_AUTHENTICATION */
#ifdef CK_ENCRYPTION
int cx_type = CX_AUTO;
extern int sl_cx_type;
#endif /* CK_ENCRYPTION */
extern char *tcp_address;
#ifndef NOHTTP
extern char * tcp_http_proxy;
extern char * tcp_http_proxy_user;
extern char * tcp_http_proxy_pwd;
extern char * tcp_http_proxy_agent;
#endif /* NOHTTP */
#ifdef NT
#ifdef CK_SOCKS
extern char *tcp_socks_svr;
extern char *tcp_socks_user;
#ifdef CK_SOCKS_NS
extern char *tcp_socks_ns;
#endif /* CK_SOCKS_NS */
#endif /* CK_SOCKS */
#endif /* NT */

#define UPW_USER  1
#define UPW_PASS  2
#define UPW_AGENT 3

static struct keytab userpass[] = {
    { "/agent",   UPW_AGENT, CM_ARG },
    { "/password", UPW_PASS, CM_ARG },
    { "/user",     UPW_USER, CM_ARG },
};
static int nuserpass = sizeof(userpass)/sizeof(struct keytab);

static struct keytab tnnegtab[] = {     /* TELNET NEGOTIATION table */
    "accepted",  TN_NG_AC, 0,
    "refused",   TN_NG_RF, 0,
    "req",       TN_NG_RQ, CM_INV|CM_ABR,
    "requ",      TN_NG_RQ, CM_INV|CM_ABR,
    "reque",     TN_NG_RQ, CM_INV|CM_ABR,
    "reques",    TN_NG_RQ, CM_INV|CM_ABR,
    "request",   TN_NG_RQ, CM_INV|CM_ABR,
    "requeste",  TN_NG_RQ, CM_INV|CM_ABR,
    "requested", TN_NG_RQ, 0,
    "required",  TN_NG_MU, 0
};
static int ntnnegtab = sizeof(tnnegtab)/sizeof(struct keytab);

#ifdef CK_ENCRYPTION
static struct keytab typkwd[] = {
    "/type", 0, CM_ARG
};

static struct keytab tnenctab[] = {     /* TELNET ENCRYPTION table */
    "accepted",   TN_NG_AC,    CM_INV,
    "refused",    TN_NG_RF,    CM_INV,
    "req",        TN_NG_RQ,    CM_INV|CM_ABR,
    "requ",       TN_NG_RQ,    CM_INV|CM_ABR,
    "reque",      TN_NG_RQ,    CM_INV|CM_ABR,
    "reques",     TN_NG_RQ,    CM_INV|CM_ABR,
    "request",    TN_NG_RQ,    CM_INV|CM_ABR,
    "requeste",   TN_NG_RQ,    CM_INV|CM_ABR,
    "requested",  TN_NG_RQ,    CM_INV,
    "required",   TN_NG_MU,    CM_INV,
    "start",      TN_EN_START, CM_INV,
    "stop",       TN_EN_STOP,  CM_INV,
    "type",       TN_EN_TYP,   0
};
static int ntnenc = sizeof(tnenctab)/sizeof(struct keytab) ;
#endif /* CK_ENCRYPTION */

#ifdef CK_FORWARD_X
static struct keytab tnfwdxtab[] = {    /* TELNET FORWARD-X table */
    "no-encryption",    1,  CM_INV,
    "xauthority-file",  0,  0
};
static int ntnfwdx = sizeof(tnfwdxtab)/sizeof(struct keytab) ;
#endif /* CK_FORWARD_X */

static struct keytab tnbugtab[] = {     /* TELNET BUG table */
    "auth-krb5-des",         4, 0,
    "binary-me-means-u-too", 0, 0,
    "binary-u-means-me-too", 1, 0,
    "infinite-loop-check",   2, 0,
    "sb-implies-will-do",    3, 0
};

#ifdef CK_ENVIRONMENT
static struct keytab tnenvtab[] = {     /* TELNET ENVIRONMENT table */
    "acct",     TN_ENV_ACCT,    0,
    "display",  TN_ENV_DISP,    0,
    "job",      TN_ENV_JOB,     0,
    "location", TN_ENV_LOC,     0,
    "off",      TN_ENV_OFF,     CM_INV,
    "on",       TN_ENV_ON,      CM_INV,
    "printer",  TN_ENV_PRNT,    0,
    "systemtype",TN_ENV_SYS,    0,
    "user",     TN_ENV_USR,     0,
    "uservar",  TN_ENV_UVAR,    0,
    "", 0, 0
};
static int ntnenv = sizeof(tnenvtab)/sizeof(struct keytab) - 1;
#endif /* CK_ENVIRONMENT */

#ifdef CK_AUTHENTICATION
static struct keytab tnauthtab[] = {    /* TELNET AUTHENTICATION table */
    "accepted",   TN_NG_AC,  CM_INV,
    "encrypt-flag", TN_AU_ENC, 0,
    "forwarding", TN_AU_FWD,   0,
    "how-flag",   TN_AU_HOW,   0,
    "refused",    TN_NG_RF,  CM_INV,
    "req",        TN_NG_RQ,  CM_INV|CM_ABR,
    "requ",       TN_NG_RQ,  CM_INV|CM_ABR,
    "reque",      TN_NG_RQ,  CM_INV|CM_ABR,
    "reques",     TN_NG_RQ,  CM_INV|CM_ABR,
    "request",    TN_NG_RQ,  CM_INV|CM_ABR,
    "requeste",   TN_NG_RQ,  CM_INV|CM_ABR,
    "requested",  TN_NG_RQ,  CM_INV,
    "required",   TN_NG_MU,  CM_INV,
    "type",       TN_AU_TYP, 0
};
static int ntnauth = sizeof(tnauthtab)/sizeof(struct keytab) ;

struct keytab autyptab[] = {    /* TELNET AUTHENTICATION TYPE table */
    "automatic",  AUTH_AUTO, 0,
#ifdef CK_KERBEROS
    "k4",         AUTH_KRB4, CM_INV,
    "k5",         AUTH_KRB5, CM_INV,
    "kerberos4",  AUTH_KRB4, 0,
    "kerberos5",  AUTH_KRB5, 0,
    "kerberos_iv",AUTH_KRB4, CM_INV,
    "kerberos_v", AUTH_KRB5, CM_INV,
    "krb4",       AUTH_KRB4, CM_INV,
    "krb5",       AUTH_KRB5, CM_INV,
#endif /* CK_KERBEROS */
    "none",       AUTH_NONE, 0,
#ifdef NT
    "ntlm",       AUTH_NTLM, 0,
#endif /* NT */
#ifdef CK_SRP
    "srp",        AUTH_SRP,  0,
#endif /* CK_SRP */
#ifdef CK_SSL
    "ssl",        AUTH_SSL,  0,
#endif /* CK_SSL */
    "", 0, 0
};
int nautyp = sizeof(autyptab)/sizeof(struct keytab) - 1;

struct keytab auhowtab[] = {    /* TELNET AUTHENTICATION HOW table */
    "any",     TN_AUTH_HOW_ANY,     0,
    "mutual",  TN_AUTH_HOW_MUTUAL,  0,
    "one-way", TN_AUTH_HOW_ONE_WAY, 0,
    "", 0, 0
};
int nauhow = sizeof(auhowtab)/sizeof(struct keytab) - 1;

struct keytab auenctab[] = {    /* TELNET AUTHENTICATION ENCRYPT table */
    "any",     TN_AUTH_ENC_ANY,     0,
    "none",    TN_AUTH_ENC_NONE,    0,
    "telopt",  TN_AUTH_ENC_TELOPT,  0,
#ifdef CK_SSL
    "tls",     TN_AUTH_ENC_TLS,     0,
#endif /* CK_SSL */
    "", 0, 0
};
int nauenc = sizeof(auenctab)/sizeof(struct keytab) - 1;
#endif /* CK_AUTHENTICATION */

#define TN_NL_BIN 3
#define TN_NL_NVT 4
static struct keytab tn_nlmtab[] = {    /* TELNET NEWLINE-MODE table */
    "binary-mode", TN_NL_BIN, 0,        /* Binary mode */
    "nvt",    TN_NL_NVT, 0,             /* NVT mode */
    "off",    TNL_CRNUL, CM_INV,        /* CR-NUL (TELNET spec) */
    "on",     TNL_CRLF,  CM_INV,        /* CR-LF (TELNET spec) */
    "raw",    TNL_CR,    CM_INV         /* CR only (out of spec) */
};
static int ntn_nlm = (sizeof(tn_nlmtab) / sizeof(struct keytab));

static struct keytab tnlmtab[] = {      /* TELNET NEWLINE-MODE table */
    "cr",     TNL_CR,    CM_INV,        /* CR only (out of spec) */
    "cr-lf",  TNL_CRLF,  CM_INV,        /* CR-LF (TELNET spec) */
    "cr-nul", TNL_CRNUL, CM_INV,        /* CR-NUL (TELNET spec) */
    "lf",     TNL_LF,    CM_INV,        /* LF instead of CR-LF */
    "off",    TNL_CRNUL, 0,             /* CR-NUL (TELNET spec) */
    "on",     TNL_CRLF,  0,             /* CR-LF (TELNET spec) */
    "raw",    TNL_CR,    0              /* CR only (out of spec) */
};
static int ntnlm = (sizeof(tnlmtab) / sizeof(struct keytab));

struct keytab tntab[] = {
#ifdef CK_AUTHENTICATION
    "authentication",       CK_TN_AU,  0,
#endif /* CK_AUTHENTICATION */
    "b",                    CK_TN_BM,  CM_INV|CM_ABR,
    "bi",                   CK_TN_BM,  CM_INV|CM_ABR,
    "bin",                  CK_TN_BM,  CM_INV|CM_ABR,
    "bina",                 CK_TN_BM,  CM_INV|CM_ABR,
    "binar",                CK_TN_BM,  CM_INV|CM_ABR,
    "binary",               CK_TN_BM,  CM_INV|CM_ABR,
    "binary-",              CK_TN_BM,  CM_INV|CM_ABR,
    "binary-mode",          CK_TN_BM,  CM_INV,
    "binary-transfer-mode", CK_TN_XF,  0,
    "binary-xfer-mode",     CK_TN_XF,  CM_INV,
    "bug",                  CK_TN_BUG, 0,
    "debug",                CK_TN_DB,  0,
    "delay-sb",             CK_TN_DL,  0,
    "echo",                 CK_TN_EC,  0,
#ifdef CK_ENCRYPTION
    "encryption",      CK_TN_ENC,  0,
#endif /* CK_ENCRYPTION */
#ifdef CK_ENVIRONMENT
    "environment",     CK_TN_ENV,  0,
#endif /* CK_ENVIRONMENT */
#ifdef CK_FORWARD_X
    "forward-x",       CK_TN_FX,   0,
#endif /* CK_FORWARD_X */
#ifdef IKS_OPTION
    "kermit",          CK_TN_IKS,  CM_INV,
#endif /* IKS_OPTION */
#ifdef CK_SNDLOC
    "location",        CK_TN_LOC,  0,
#endif /* CK_SNDLOC */
#ifdef CK_NAWS
    "naws",            CK_TN_NAWS, CM_INV,
#endif /* CK_NAWS */
    "newline-mode",    CK_TN_NL,   0,
    "no-encrypt-during-xfer", CK_TN_NE, CM_INV,
    "prompt-for-userid",CK_TN_PUID,0,
    "remote-echo",     CK_TN_RE,   0,
#ifdef CK_SSL
    "start-tls",       CK_TN_TLS,  CM_INV,
#endif /* CK_SSL */
#ifdef NT
    "sfu-compatibility", CK_TN_SFU, 0,
#else
    "sfu-compatibility", CK_TN_SFU, CM_INV,
#endif /* NT */
    "terminal-type",   CK_TN_TT,   0,
    "wait-for-negotiations", CK_TN_WAIT, 0,
#ifdef CK_ENVIRONMENT
    "xdisplay-location",CK_TN_XD, CM_INV,
#endif /* CK_ENVIRONMENT */
    "", 0, 0
};
int ntn = (sizeof(tntab) / sizeof(struct keytab)) - 1;

struct keytab tnopttab[] = {
#ifdef CK_AUTHENTICATION
    "authentication",  CK_TN_AU,   0,
#else
    "authentication",  CK_TN_AU,   CM_INV,
#endif /* CK_AUTHENTICATION */
    "binary-mode",     CK_TN_BM,   0,
#ifdef TN_COMPORT
    "c",               CK_TN_CPC,   CM_INV|CM_ABR,
    "co",              CK_TN_CPC,   CM_INV|CM_ABR,
    "com",             CK_TN_CPC,   CM_INV|CM_ABR,
    "com-port-control",CK_TN_CPC,   0,
    "comport-control", CK_TN_CPC,   CM_INV,
#else /* TN_COMPORT */
    "com-port-control",CK_TN_CPC,  CM_INV,
    "comport-control", CK_TN_CPC,   CM_INV,
#endif /* TN_COMPORT */
    "echo",            CK_TN_EC,   0,
#ifdef CK_ENCRYPTION
    "encryption",      CK_TN_ENC,  0,
#else
    "encryption",      CK_TN_ENC,  CM_INV,
#endif /* CK_ENCRYPTION */
#ifdef CK_FORWARD_X
    "forward-x",       CK_TN_FX,   0,
#else /* CK_FORWARD_X */
    "forward-x",       CK_TN_FX,   CM_INV,
#endif /* CK_FORWARD_X */
    "ibm-sak",         CK_TN_SAK,  CM_INV,
#ifdef IKS_OPTION
    "kermit",          CK_TN_IKS,  0,
#else
    "kermit",          CK_TN_IKS,  CM_INV,
#endif /* IKS_OPTION */
    "lflow",           CK_TN_FLW,  CM_INV,
    "logout",          CK_TN_LOG,  0,
#ifdef CK_NAWS
    "naws",            CK_TN_NAWS, 0,
#else
    "naws",            CK_TN_NAWS, CM_INV,
#endif /* CK_NAWS */
#ifdef CK_ENVIRONMENT
    "new-environment", CK_TN_ENV,  0,
#else
    "new-environment", CK_TN_ENV,  CM_INV,
#endif /* CK_ENVIRONMENT */
    "pragma-heartbeat",CK_TN_PHR,  CM_INV,
    "pragma-logon",    CK_TN_PLG,  CM_INV,
    "pragma-sspi",     CK_TN_PSP,  CM_INV,
    "sak",             CK_TN_SAK,  CM_INV,
#ifdef CK_SNDLOC
    "send-location",   CK_TN_LOC,  0,
#else
    "send-location",   CK_TN_LOC,  CM_INV,
#endif /* CK_SNDLOC */
    "sga",             CK_TN_SGA, CM_INV|CM_ABR,
#ifdef CK_SSL
    "start-tls",       CK_TN_TLS,  0,
#else
    "start-tls",       CK_TN_TLS,  CM_INV,
#endif /* CK_SSL */