void *frontend;
+ int ospeed, ispeed; /* temporaries */
int term_width, term_height;
tree234 *channels; /* indexed by local id */
#define logevent(s) logevent(ssh->frontend, s)
/* logevent, only printf-formatted. */
-static void logeventf(Ssh ssh, char *fmt, ...)
+static void logeventf(Ssh ssh, const char *fmt, ...)
{
va_list ap;
char *buf;
if (ssh->cipher)
ssh->cipher->decrypt(ssh->v1_cipher_ctx, ssh->pktin.data, st->biglen);
- st->realcrc = crc32(ssh->pktin.data, st->biglen - 4);
+ st->realcrc = crc32_compute(ssh->pktin.data, st->biglen - 4);
st->gotcrc = GET_32BIT(ssh->pktin.data + st->biglen - 4);
if (st->gotcrc != st->realcrc) {
bombout(("Incorrect CRC received on packet"));
}
ssh->pktin.body = ssh->pktin.data + st->pad + 1;
+ ssh->pktin.savedpos = 0;
if (ssh->v1_compressing) {
unsigned char *decompblk;
int decomplen;
- zlib_decompress_block(ssh->sc_comp_ctx,
- ssh->pktin.body - 1, ssh->pktin.length + 1,
- &decompblk, &decomplen);
+ if (!zlib_decompress_block(ssh->sc_comp_ctx,
+ ssh->pktin.body - 1, ssh->pktin.length + 1,
+ &decompblk, &decomplen)) {
+ bombout(("Zlib decompression encountered invalid data"));
+ crStop(0);
+ }
if (ssh->pktin.maxlen < st->pad + decomplen) {
ssh->pktin.maxlen = st->pad + decomplen;
}
ssh->pktin.savedpos = 6;
+ ssh->pktin.body = ssh->pktin.data;
ssh->pktin.type = ssh->pktin.data[5];
if (ssh->logctx)
for (i = 0; i < pad; i++)
ssh->pktout.data[i + 4] = random_byte();
- crc = crc32(ssh->pktout.data + 4, biglen - 4);
+ crc = crc32_compute(ssh->pktout.data + 4, biglen - 4);
PUT_32BIT(ssh->pktout.data + biglen, crc);
PUT_32BIT(ssh->pktout.data, len);
}
/*
- * SSH2 packet decode functions.
+ * Packet decode functions for both SSH1 and SSH2.
*/
-static unsigned long ssh2_pkt_getuint32(Ssh ssh)
+static unsigned long ssh_pkt_getuint32(Ssh ssh)
{
unsigned long value;
if (ssh->pktin.length - ssh->pktin.savedpos < 4)
return 0; /* arrgh, no way to decline (FIXME?) */
- value = GET_32BIT(ssh->pktin.data + ssh->pktin.savedpos);
+ value = GET_32BIT(ssh->pktin.body + ssh->pktin.savedpos);
ssh->pktin.savedpos += 4;
return value;
}
unsigned long value;
if (ssh->pktin.length - ssh->pktin.savedpos < 1)
return 0; /* arrgh, no way to decline (FIXME?) */
- value = ssh->pktin.data[ssh->pktin.savedpos] != 0;
+ value = ssh->pktin.body[ssh->pktin.savedpos] != 0;
ssh->pktin.savedpos++;
return value;
}
-static void ssh2_pkt_getstring(Ssh ssh, char **p, int *length)
+static void ssh_pkt_getstring(Ssh ssh, char **p, int *length)
{
int len;
*p = NULL;
*length = 0;
if (ssh->pktin.length - ssh->pktin.savedpos < 4)
return;
- len = GET_32BIT(ssh->pktin.data + ssh->pktin.savedpos);
+ len = GET_32BIT(ssh->pktin.body + ssh->pktin.savedpos);
if (len < 0)
return;
*length = len;
ssh->pktin.savedpos += 4;
if (ssh->pktin.length - ssh->pktin.savedpos < *length)
return;
- *p = (char *)(ssh->pktin.data + ssh->pktin.savedpos);
+ *p = (char *)(ssh->pktin.body + ssh->pktin.savedpos);
ssh->pktin.savedpos += *length;
}
+static void *ssh_pkt_getdata(Ssh ssh, int length)
+{
+ if (ssh->pktin.length - ssh->pktin.savedpos < length)
+ return NULL;
+ ssh->pktin.savedpos += length;
+ return ssh->pktin.body + (ssh->pktin.savedpos - length);
+}
+static int ssh1_pkt_getrsakey(Ssh ssh, struct RSAKey *key,
+ unsigned char **keystr)
+{
+ int j;
+
+ j = makekey(ssh->pktin.body + ssh->pktin.savedpos,
+ ssh->pktin.length - ssh->pktin.savedpos,
+ key, keystr, 0);
+
+ if (j < 0)
+ return FALSE;
+
+ ssh->pktin.savedpos += j;
+ assert(ssh->pktin.savedpos < ssh->pktin.length);
+
+ return TRUE;
+}
+static Bignum ssh1_pkt_getmp(Ssh ssh)
+{
+ int j;
+ Bignum b;
+
+ j = ssh1_read_bignum(ssh->pktin.body + ssh->pktin.savedpos,
+ ssh->pktin.length - ssh->pktin.savedpos, &b);
+
+ if (j < 0)
+ return NULL;
+
+ ssh->pktin.savedpos += j;
+ return b;
+}
static Bignum ssh2_pkt_getmp(Ssh ssh)
{
char *p;
int length;
Bignum b;
- ssh2_pkt_getstring(ssh, &p, &length);
+ ssh_pkt_getstring(ssh, &p, &length);
if (!p)
return NULL;
if (p[0] & 0x80) {
(ssh->cfg.sshbug_ignore1 == AUTO &&
(!strcmp(imp, "1.2.18") || !strcmp(imp, "1.2.19") ||
!strcmp(imp, "1.2.20") || !strcmp(imp, "1.2.21") ||
- !strcmp(imp, "1.2.22") || !strcmp(imp, "Cisco-1.25")))) {
+ !strcmp(imp, "1.2.22") || !strcmp(imp, "Cisco-1.25") ||
+ !strcmp(imp, "OSU_1.4alpha3")))) {
/*
* These versions don't support SSH1_MSG_IGNORE, so we have
* to use a different defence against password length
if (ssh->cfg.sshbug_plainpw1 == FORCE_ON ||
(ssh->cfg.sshbug_plainpw1 == AUTO &&
- (!strcmp(imp, "Cisco-1.25")))) {
+ (!strcmp(imp, "Cisco-1.25") || !strcmp(imp, "OSU_1.4alpha3")))) {
/*
* These versions need a plain password sent; they can't
* handle having a null and a random length of data after
if (ssh->cfg.sshbug_hmac2 == FORCE_ON ||
(ssh->cfg.sshbug_hmac2 == AUTO &&
+ !wc_match("* VShell", imp) &&
(wc_match("2.1.0*", imp) || wc_match("2.0.*", imp) ||
wc_match("2.2.0*", imp) || wc_match("2.3.0*", imp) ||
wc_match("2.1 *", imp)))) {
if (ssh->cfg.sshbug_derivekey2 == FORCE_ON ||
(ssh->cfg.sshbug_derivekey2 == AUTO &&
+ !wc_match("* VShell", imp) &&
(wc_match("2.0.0*", imp) || wc_match("2.0.10*", imp) ))) {
/*
* These versions have the key-derivation bug (failing to
}
}
-static int ssh_closing(Plug plug, char *error_msg, int error_code,
+static int ssh_closing(Plug plug, const char *error_msg, int error_code,
int calling_back)
{
Ssh ssh = (Ssh) plug;
if (error_msg) {
/* A socket error has occurred. */
logevent(error_msg);
- connection_fatal(ssh->frontend, error_msg);
+ connection_fatal(ssh->frontend, "%s", error_msg);
} else {
/* Otherwise, the remote side closed the connection normally. */
}
* Also places the canonical host name into `realhost'. It must be
* freed by the caller.
*/
-static char *connect_to_host(Ssh ssh, char *host, int port,
- char **realhost, int nodelay)
+static const char *connect_to_host(Ssh ssh, char *host, int port,
+ char **realhost, int nodelay, int keepalive)
{
static const struct plug_function_table fn_table = {
ssh_closing,
};
SockAddr addr;
- char *err;
+ const char *err;
ssh->savedhost = snewn(1 + strlen(host), char);
if (!ssh->savedhost)
*/
logeventf(ssh, "Looking up host \"%s\"", host);
addr = name_lookup(host, port, realhost, &ssh->cfg);
- if ((err = sk_addr_error(addr)) != NULL)
+ if ((err = sk_addr_error(addr)) != NULL) {
+ sk_addr_free(addr);
return err;
+ }
/*
* Open socket.
}
ssh->fn = &fn_table;
ssh->s = new_connection(addr, *realhost, port,
- 0, 1, nodelay, (Plug) ssh, &ssh->cfg);
+ 0, 1, nodelay, keepalive, (Plug) ssh, &ssh->cfg);
if ((err = sk_socket_error(ssh->s)) != NULL) {
ssh->s = NULL;
return err;
return 0;
}
-void ssh_agent_callback(void *sshv, void *reply, int replylen)
+static void ssh_agent_callback(void *sshv, void *reply, int replylen)
{
Ssh ssh = (Ssh) sshv;
do_ssh2_authconn(ssh, NULL, -1, 0);
}
-void ssh_agentf_callback(void *cv, void *reply, int replylen)
+static void ssh_agentf_callback(void *cv, void *reply, int replylen)
{
struct ssh_channel *c = (struct ssh_channel *)cv;
Ssh ssh = c->ssh;
*/
static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen, int ispkt)
{
- int i, j;
- unsigned char cookie[8];
+ int i, j, ret;
+ unsigned char cookie[8], *ptr;
struct RSAKey servkey, hostkey;
struct MD5Context md5c;
struct do_ssh1_login_state {
logevent("Received public keys");
- memcpy(cookie, ssh->pktin.body, 8);
+ ptr = ssh_pkt_getdata(ssh, 8);
+ if (!ptr) {
+ bombout(("SSH1 public key packet stopped before random cookie"));
+ crStop(0);
+ }
+ memcpy(cookie, ptr, 8);
- i = makekey(ssh->pktin.body + 8, &servkey, &s->keystr1, 0);
- j = makekey(ssh->pktin.body + 8 + i, &hostkey, &s->keystr2, 0);
+ if (!ssh1_pkt_getrsakey(ssh, &servkey, &s->keystr1) ||
+ !ssh1_pkt_getrsakey(ssh, &hostkey, &s->keystr2)) {
+ bombout(("SSH1 public key packet stopped before public keys"));
+ crStop(0);
+ }
/*
* Log the host key fingerprint.
logevent(logmsg);
}
- ssh->v1_remote_protoflags = GET_32BIT(ssh->pktin.body + 8 + i + j);
- s->supported_ciphers_mask = GET_32BIT(ssh->pktin.body + 12 + i + j);
- s->supported_auths_mask = GET_32BIT(ssh->pktin.body + 16 + i + j);
+ ssh->v1_remote_protoflags = ssh_pkt_getuint32(ssh);
+ s->supported_ciphers_mask = ssh_pkt_getuint32(ssh);
+ s->supported_auths_mask = ssh_pkt_getuint32(ssh);
ssh->v1_local_protoflags =
ssh->v1_remote_protoflags & SSH1_PROTOFLAGS_SUPPORTED;
MD5Init(&md5c);
MD5Update(&md5c, s->keystr2, hostkey.bytes);
MD5Update(&md5c, s->keystr1, servkey.bytes);
- MD5Update(&md5c, ssh->pktin.body, 8);
+ MD5Update(&md5c, cookie, 8);
MD5Final(s->session_id, &md5c);
for (i = 0; i < 32; i++)
ssh->session_key[i] = random_byte();
+ /*
+ * Verify that the `bits' and `bytes' parameters match.
+ */
+ if (hostkey.bits > hostkey.bytes * 8 ||
+ servkey.bits > servkey.bytes * 8) {
+ bombout(("SSH1 public keys were badly formatted"));
+ crStop(0);
+ }
+
s->len = (hostkey.bytes > servkey.bytes ? hostkey.bytes : servkey.bytes);
s->rsabuf = snewn(s->len, unsigned char);
}
if (hostkey.bytes > servkey.bytes) {
- rsaencrypt(s->rsabuf, 32, &servkey);
- rsaencrypt(s->rsabuf, servkey.bytes, &hostkey);
+ ret = rsaencrypt(s->rsabuf, 32, &servkey);
+ if (ret)
+ ret = rsaencrypt(s->rsabuf, servkey.bytes, &hostkey);
} else {
- rsaencrypt(s->rsabuf, 32, &hostkey);
- rsaencrypt(s->rsabuf, hostkey.bytes, &servkey);
+ ret = rsaencrypt(s->rsabuf, 32, &hostkey);
+ if (ret)
+ ret = rsaencrypt(s->rsabuf, hostkey.bytes, &servkey);
+ }
+ if (!ret) {
+ bombout(("SSH1 public key encryptions failed due to bad formatting"));
+ crStop(0);
}
logevent("Encrypted session key");
ssh->crcda_ctx = crcda_make_context();
logevent("Installing CRC compensation attack detector");
+ if (servkey.modulus) {
+ sfree(servkey.modulus);
+ servkey.modulus = NULL;
+ }
+ if (servkey.exponent) {
+ sfree(servkey.exponent);
+ servkey.exponent = NULL;
+ }
+ if (hostkey.modulus) {
+ sfree(hostkey.modulus);
+ hostkey.modulus = NULL;
+ }
+ if (hostkey.exponent) {
+ sfree(hostkey.exponent);
+ hostkey.exponent = NULL;
+ }
crWaitUntil(ispkt);
if (ssh->pktin.type != SSH1_SMSG_SUCCESS) {
/* Load the public half of ssh->cfg.keyfile so we notice if it's in Pageant */
if (!filename_is_null(ssh->cfg.keyfile)) {
if (!rsakey_pubblob(&ssh->cfg.keyfile,
- &s->publickey_blob, &s->publickey_bloblen))
+ &s->publickey_blob, &s->publickey_bloblen, NULL))
s->publickey_blob = NULL;
} else
s->publickey_blob = NULL;
s->tried_publickey = 1;
}
s->p += 4;
- s->p += ssh1_read_bignum(s->p, &s->key.exponent);
- s->p += ssh1_read_bignum(s->p, &s->key.modulus);
- s->commentlen = GET_32BIT(s->p);
- s->p += 4;
- s->commentp = (char *)s->p;
- s->p += s->commentlen;
+ {
+ int n, ok = FALSE;
+ do { /* do while (0) to make breaking easy */
+ n = ssh1_read_bignum
+ (s->p, s->responselen-(s->p-s->response),
+ &s->key.exponent);
+ if (n < 0)
+ break;
+ s->p += n;
+ n = ssh1_read_bignum
+ (s->p, s->responselen-(s->p-s->response),
+ &s->key.modulus);
+ if (n < 0)
+ break;
+ s->p += n;
+ if (s->responselen - (s->p-s->response) < 4)
+ break;
+ s->commentlen = GET_32BIT(s->p);
+ s->p += 4;
+ if (s->responselen - (s->p-s->response) <
+ s->commentlen)
+ break;
+ s->commentp = (char *)s->p;
+ s->p += s->commentlen;
+ ok = TRUE;
+ } while (0);
+ if (!ok) {
+ logevent("Pageant key list packet was truncated");
+ break;
+ }
+ }
send_packet(ssh, SSH1_CMSG_AUTH_RSA,
PKT_BIGNUM, s->key.modulus, PKT_END);
crWaitUntil(ispkt);
continue;
}
logevent("Received RSA challenge");
- ssh1_read_bignum(ssh->pktin.body, &s->challenge);
+ if ((s->challenge = ssh1_pkt_getmp(ssh)) == NULL) {
+ bombout(("Server's RSA challenge was badly formatted"));
+ crStop(0);
+ }
+
{
char *agentreq, *q, *ret;
void *vret;
if (s->authed)
break;
}
+ sfree(s->response);
}
if (s->authed)
break;
s->tis_auth_refused = 1;
continue;
} else {
- int challengelen = GET_32BIT(ssh->pktin.body);
+ char *challenge;
+ int challengelen;
+
+ ssh_pkt_getstring(ssh, &challenge, &challengelen);
+ if (!challenge) {
+ bombout(("TIS challenge packet was badly formed"));
+ crStop(0);
+ }
logevent("Received TIS challenge");
if (challengelen > sizeof(s->prompt) - 1)
challengelen = sizeof(s->prompt) - 1;/* prevent overrun */
- memcpy(s->prompt, ssh->pktin.body + 4, challengelen);
+ memcpy(s->prompt, challenge, challengelen);
/* Prompt heuristic comes from OpenSSH */
strncpy(s->prompt + challengelen,
memchr(s->prompt, '\n', challengelen) ?
s->ccard_auth_refused = 1;
continue;
} else {
- int challengelen = GET_32BIT(ssh->pktin.body);
+ char *challenge;
+ int challengelen;
+
+ ssh_pkt_getstring(ssh, &challenge, &challengelen);
+ if (!challenge) {
+ bombout(("CryptoCard challenge packet was badly formed"));
+ crStop(0);
+ }
logevent("Received CryptoCard challenge");
if (challengelen > sizeof(s->prompt) - 1)
challengelen = sizeof(s->prompt) - 1;/* prevent overrun */
- memcpy(s->prompt, ssh->pktin.body + 4, challengelen);
+ memcpy(s->prompt, challenge, challengelen);
strncpy(s->prompt + challengelen,
memchr(s->prompt, '\n', challengelen) ?
"" : "\r\nResponse: ",
s->tried_publickey = 1;
{
- int ret = loadrsakey(&ssh->cfg.keyfile, &s->key, s->password);
+ const char *error = NULL;
+ int ret = loadrsakey(&ssh->cfg.keyfile, &s->key, s->password,
+ &error);
if (ret == 0) {
c_write_str(ssh, "Couldn't load private key from ");
c_write_str(ssh, filename_to_str(&ssh->cfg.keyfile));
- c_write_str(ssh, ".\r\n");
+ c_write_str(ssh, " (");
+ c_write_str(ssh, error);
+ c_write_str(ssh, ").\r\n");
continue; /* go and try password */
}
if (ret == -1) {
unsigned char buffer[32];
Bignum challenge, response;
- ssh1_read_bignum(ssh->pktin.body, &challenge);
+ if ((challenge = ssh1_pkt_getmp(ssh)) == NULL) {
+ bombout(("Server's RSA challenge was badly formatted"));
+ crStop(0);
+ }
response = rsadecrypt(challenge, &s->key);
freebn(s->key.private_exponent);/* burn the evidence */
}
logevent("Sending password with camouflage packets");
ssh_pkt_defersend(ssh);
+ sfree(randomstr);
}
else if (!(ssh->remote_bugs & BUG_NEEDS_SSH1_PLAIN_PASSWORD)) {
/*
} else {
while (*ssh->portfwd_strptr) ssh->portfwd_strptr++;
dport = dserv = -1;
+ ssh->portfwd_strptr++; /* eat the NUL and move to next one */
}
sport = atoi(sports);
sserv = 0;
}
if (!ssh->cfg.nopty) {
+ /* Unpick the terminal-speed string. */
+ /* XXX perhaps we should allow no speeds to be sent. */
+ ssh->ospeed = 38400; ssh->ispeed = 38400; /* last-resort defaults */
+ sscanf(ssh->cfg.termspeed, "%d,%d", &ssh->ospeed, &ssh->ispeed);
+ /* Send the pty request. */
send_packet(ssh, SSH1_CMSG_REQUEST_PTY,
PKT_STR, ssh->cfg.termtype,
PKT_INT, ssh->term_height,
PKT_INT, ssh->term_width,
- PKT_INT, 0, PKT_INT, 0, PKT_CHAR, 0, PKT_END);
+ PKT_INT, 0, PKT_INT, 0, /* width,height in pixels */
+ PKT_CHAR, 192, PKT_INT, ssh->ispeed, /* TTY_OP_ISPEED */
+ PKT_CHAR, 193, PKT_INT, ssh->ospeed, /* TTY_OP_OSPEED */
+ PKT_CHAR, 0, PKT_END);
ssh->state = SSH_STATE_INTERMED;
do {
crReturnV;
c_write_str(ssh, "Server refused to allocate pty\r\n");
ssh->editing = ssh->echoing = 1;
}
- logevent("Allocated pty");
+ logeventf(ssh, "Allocated pty (ospeed %dbps, ispeed %dbps)",
+ ssh->ospeed, ssh->ispeed);
} else {
ssh->editing = ssh->echoing = 1;
}
if (ispkt) {
if (ssh->pktin.type == SSH1_SMSG_STDOUT_DATA ||
ssh->pktin.type == SSH1_SMSG_STDERR_DATA) {
- long len = GET_32BIT(ssh->pktin.body);
- int bufsize =
+ char *string;
+ int stringlen, bufsize;
+
+ ssh_pkt_getstring(ssh, &string, &stringlen);
+ if (string == NULL) {
+ bombout(("Incoming terminal data packet was badly formed"));
+ crStopV;
+ }
+
+ bufsize =
from_backend(ssh->frontend,
ssh->pktin.type == SSH1_SMSG_STDERR_DATA,
- (char *)(ssh->pktin.body) + 4, len);
+ string, stringlen);
if (!ssh->v1_stdout_throttling && bufsize > SSH1_BUFFER_LIMIT) {
ssh->v1_stdout_throttling = 1;
ssh1_throttle(ssh, +1);
/* Remote side is trying to open a channel to talk to our
* X-Server. Give them back a local channel number. */
struct ssh_channel *c;
+ int remoteid = ssh_pkt_getuint32(ssh);
logevent("Received X11 connect request");
/* Refuse if X11 forwarding is disabled. */
if (!ssh->X11_fwd_enabled) {
send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
- PKT_INT, GET_32BIT(ssh->pktin.body), PKT_END);
+ PKT_INT, remoteid, PKT_END);
logevent("Rejected X11 connect request");
} else {
c = snew(struct ssh_channel);
if (x11_init(&c->u.x11.s, ssh->cfg.x11_display, c,
ssh->x11auth, NULL, -1, &ssh->cfg) != NULL) {
- logevent("opening X11 forward connection failed");
+ logevent("Opening X11 forward connection failed");
sfree(c);
send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
- PKT_INT, GET_32BIT(ssh->pktin.body),
- PKT_END);
+ PKT_INT, remoteid, PKT_END);
} else {
logevent
- ("opening X11 forward connection succeeded");
- c->remoteid = GET_32BIT(ssh->pktin.body);
+ ("Opening X11 forward connection succeeded");
+ c->remoteid = remoteid;
c->localid = alloc_channel_id(ssh);
c->closes = 0;
c->v.v1.throttling = 0;
/* Remote side is trying to open a channel to talk to our
* agent. Give them back a local channel number. */
struct ssh_channel *c;
+ int remoteid = ssh_pkt_getuint32(ssh);
/* Refuse if agent forwarding is disabled. */
if (!ssh->agentfwd_enabled) {
send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
- PKT_INT, GET_32BIT(ssh->pktin.body), PKT_END);
+ PKT_INT, remoteid, PKT_END);
} else {
c = snew(struct ssh_channel);
c->ssh = ssh;
- c->remoteid = GET_32BIT(ssh->pktin.body);
+ c->remoteid = remoteid;
c->localid = alloc_channel_id(ssh);
c->closes = 0;
c->v.v1.throttling = 0;
* forwarded port. Give them back a local channel number. */
struct ssh_channel *c;
struct ssh_rportfwd pf;
+ int remoteid;
int hostsize, port;
- char host[256], buf[1024];
- char *p, *h, *e;
+ char *host, buf[1024];
+ const char *e;
c = snew(struct ssh_channel);
c->ssh = ssh;
- hostsize = GET_32BIT(ssh->pktin.body+4);
- for (h = host, p = (char *)(ssh->pktin.body+8);
- hostsize != 0; hostsize--) {
- if (h+1 < host+sizeof(host))
- *h++ = *p;
- p++;
- }
- *h = 0;
- port = GET_32BIT(p);
+ remoteid = ssh_pkt_getuint32(ssh);
+ ssh_pkt_getstring(ssh, &host, &hostsize);
+ port = ssh_pkt_getuint32(ssh);
- strcpy(pf.dhost, host);
+ if (hostsize >= lenof(pf.dhost))
+ hostsize = lenof(pf.dhost)-1;
+ memcpy(pf.dhost, host, hostsize);
+ pf.dhost[hostsize] = '\0';
pf.dport = port;
if (find234(ssh->rportfwds, &pf, NULL) == NULL) {
sprintf(buf, "Rejected remote port open request for %s:%d",
- host, port);
+ pf.dhost, port);
logevent(buf);
send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
- PKT_INT, GET_32BIT(ssh->pktin.body), PKT_END);
+ PKT_INT, remoteid, PKT_END);
} else {
sprintf(buf, "Received remote port open request for %s:%d",
- host, port);
+ pf.dhost, port);
logevent(buf);
- e = pfd_newconnect(&c->u.pfd.s, host, port, c, &ssh->cfg);
+ e = pfd_newconnect(&c->u.pfd.s, pf.dhost, port,
+ c, &ssh->cfg);
if (e != NULL) {
char buf[256];
sprintf(buf, "Port open failed: %s", e);
logevent(buf);
sfree(c);
send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
- PKT_INT, GET_32BIT(ssh->pktin.body),
- PKT_END);
+ PKT_INT, remoteid, PKT_END);
} else {
- c->remoteid = GET_32BIT(ssh->pktin.body);
+ c->remoteid = remoteid;
c->localid = alloc_channel_id(ssh);
c->closes = 0;
c->v.v1.throttling = 0;
}
} else if (ssh->pktin.type == SSH1_MSG_CHANNEL_OPEN_CONFIRMATION) {
- unsigned int remoteid = GET_32BIT(ssh->pktin.body);
- unsigned int localid = GET_32BIT(ssh->pktin.body+4);
+ unsigned int remoteid = ssh_pkt_getuint32(ssh);
+ unsigned int localid = ssh_pkt_getuint32(ssh);
struct ssh_channel *c;
c = find234(ssh->channels, &remoteid, ssh_channelfind);
}
} else if (ssh->pktin.type == SSH1_MSG_CHANNEL_OPEN_FAILURE) {
- unsigned int remoteid = GET_32BIT(ssh->pktin.body);
+ unsigned int remoteid = ssh_pkt_getuint32(ssh);
struct ssh_channel *c;
c = find234(ssh->channels, &remoteid, ssh_channelfind);
} else if (ssh->pktin.type == SSH1_MSG_CHANNEL_CLOSE ||
ssh->pktin.type == SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION) {
/* Remote side closes a channel. */
- unsigned i = GET_32BIT(ssh->pktin.body);
+ unsigned i = ssh_pkt_getuint32(ssh);
struct ssh_channel *c;
c = find234(ssh->channels, &i, ssh_channelfind);
if (c && ((int)c->remoteid) != -1) {
}
} else if (ssh->pktin.type == SSH1_MSG_CHANNEL_DATA) {
/* Data sent down one of our channels. */
- int i = GET_32BIT(ssh->pktin.body);
- int len = GET_32BIT(ssh->pktin.body + 4);
- unsigned char *p = ssh->pktin.body + 8;
+ int i = ssh_pkt_getuint32(ssh);
+ char *p;
+ int len;
struct ssh_channel *c;
+
+ ssh_pkt_getstring(ssh, &p, &len);
+
c = find234(ssh->channels, &i, ssh_channelfind);
if (c) {
int bufsize = 0;
switch (c->type) {
case CHAN_X11:
- bufsize = x11_send(c->u.x11.s, (char *)p, len);
+ bufsize = x11_send(c->u.x11.s, p, len);
break;
case CHAN_SOCKDATA:
- bufsize = pfd_send(c->u.pfd.s, (char *)p, len);
+ bufsize = pfd_send(c->u.pfd.s, p, len);
break;
case CHAN_AGENT:
/* Data for an agent message. Buffer it. */
* if no pty is available or in other odd cases. Ignore */
} else if (ssh->pktin.type == SSH1_SMSG_EXIT_STATUS) {
char buf[100];
- ssh->exitcode = GET_32BIT(ssh->pktin.body);
+ ssh->exitcode = ssh_pkt_getuint32(ssh);
sprintf(buf, "Server sent command exit status %d",
ssh->exitcode);
logevent(buf);
s->cscomp_tobe = NULL;
s->sccomp_tobe = NULL;
ssh->pktin.savedpos += 16; /* skip garbage cookie */
- ssh2_pkt_getstring(ssh, &str, &len); /* key exchange algorithms */
+ ssh_pkt_getstring(ssh, &str, &len); /* key exchange algorithms */
for (i = 0; i < lenof(kex_algs); i++) {
if (kex_algs[i] == &ssh_diffiehellman_gex &&
(ssh->remote_bugs & BUG_SSH2_DH_GEX))
break;
}
}
- ssh2_pkt_getstring(ssh, &str, &len); /* host key algorithms */
+ ssh_pkt_getstring(ssh, &str, &len); /* host key algorithms */
for (i = 0; i < lenof(hostkey_algs); i++) {
if (in_commasep_string(hostkey_algs[i]->name, str, len)) {
ssh->hostkey = hostkey_algs[i];
break;
}
}
- ssh2_pkt_getstring(ssh, &str, &len); /* client->server cipher */
+ ssh_pkt_getstring(ssh, &str, &len); /* client->server cipher */
s->warn = 0;
for (i = 0; i < s->n_preferred_ciphers; i++) {
const struct ssh2_ciphers *c = s->preferred_ciphers[i];
crStop(0);
}
- ssh2_pkt_getstring(ssh, &str, &len); /* server->client cipher */
+ ssh_pkt_getstring(ssh, &str, &len); /* server->client cipher */
s->warn = 0;
for (i = 0; i < s->n_preferred_ciphers; i++) {
const struct ssh2_ciphers *c = s->preferred_ciphers[i];
crStop(0);
}
- ssh2_pkt_getstring(ssh, &str, &len); /* client->server mac */
+ ssh_pkt_getstring(ssh, &str, &len); /* client->server mac */
for (i = 0; i < s->nmacs; i++) {
if (in_commasep_string(s->maclist[i]->name, str, len)) {
s->csmac_tobe = s->maclist[i];
break;
}
}
- ssh2_pkt_getstring(ssh, &str, &len); /* server->client mac */
+ ssh_pkt_getstring(ssh, &str, &len); /* server->client mac */
for (i = 0; i < s->nmacs; i++) {
if (in_commasep_string(s->maclist[i]->name, str, len)) {
s->scmac_tobe = s->maclist[i];
break;
}
}
- ssh2_pkt_getstring(ssh, &str, &len); /* client->server compression */
+ ssh_pkt_getstring(ssh, &str, &len); /* client->server compression */
for (i = 0; i < lenof(compressions) + 1; i++) {
const struct ssh_compress *c =
i == 0 ? s->preferred_comp : compressions[i - 1];
break;
}
}
- ssh2_pkt_getstring(ssh, &str, &len); /* server->client compression */
+ ssh_pkt_getstring(ssh, &str, &len); /* server->client compression */
for (i = 0; i < lenof(compressions) + 1; i++) {
const struct ssh_compress *c =
i == 0 ? s->preferred_comp : compressions[i - 1];
bombout(("expected key exchange reply packet from server"));
crStop(0);
}
- ssh2_pkt_getstring(ssh, &s->hostkeydata, &s->hostkeylen);
+ ssh_pkt_getstring(ssh, &s->hostkeydata, &s->hostkeylen);
s->f = ssh2_pkt_getmp(ssh);
- ssh2_pkt_getstring(ssh, &s->sigdata, &s->siglen);
+ ssh_pkt_getstring(ssh, &s->sigdata, &s->siglen);
s->K = dh_find_K(ssh->kex_ctx, s->f);
if (ssh->sccomp->text_name)
logeventf(ssh, "Initialised %s decompression",
ssh->sccomp->text_name);
+ freebn(s->f);
+ freebn(s->K);
+ if (ssh->kex == &ssh_diffiehellman_gex) {
+ freebn(s->g);
+ freebn(s->p);
+ }
/*
* If this is the first key exchange phase, we must pass the
if (keytype == SSH_KEYTYPE_SSH2) {
s->publickey_blob =
ssh2_userkey_loadpub(&ssh->cfg.keyfile, NULL,
- &s->publickey_bloblen);
+ &s->publickey_bloblen, NULL);
} else {
char *msgbuf;
logeventf(ssh, "Unable to use this key file (%s)",
* output of (say) plink.)
*/
if (flags & (FLAG_VERBOSE | FLAG_INTERACTIVE)) {
- ssh2_pkt_getstring(ssh, &banner, &size);
+ ssh_pkt_getstring(ssh, &banner, &size);
if (banner)
c_write_untrusted(ssh, banner, size);
}
if (ssh->pktin.type == SSH2_MSG_USERAUTH_FAILURE) {
char *methods;
int methlen;
- ssh2_pkt_getstring(ssh, &methods, &methlen);
+ ssh_pkt_getstring(ssh, &methods, &methlen);
s->kbd_inter_running = FALSE;
if (!ssh2_pkt_getbool(ssh)) {
/*
s->method = 0;
ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
+ s->need_pw = FALSE;
/*
* Most password/passphrase prompts will be
if (s->authed)
continue;
}
+ sfree(s->response);
}
if (!s->method && s->can_pubkey && s->publickey_blob
pub_blob =
(unsigned char *)ssh2_userkey_loadpub(&ssh->cfg.keyfile,
&algorithm,
- &pub_blob_len);
+ &pub_blob_len,
+ NULL);
if (pub_blob) {
ssh2_pkt_init(ssh, SSH2_MSG_USERAUTH_REQUEST);
ssh2_pkt_addstring(ssh, s->username);
} else {
s->need_pw = FALSE;
}
- c_write_str(ssh, "Authenticating with public key \"");
- c_write_str(ssh, comment);
- c_write_str(ssh, "\"\r\n");
+ if (flags & FLAG_VERBOSE) {
+ c_write_str(ssh, "Authenticating with public key \"");
+ c_write_str(ssh, comment);
+ c_write_str(ssh, "\"\r\n");
+ }
s->method = AUTH_PUBLICKEY_FILE;
}
}
char *name, *inst, *lang;
int name_len, inst_len, lang_len;
- ssh2_pkt_getstring(ssh, &name, &name_len);
- ssh2_pkt_getstring(ssh, &inst, &inst_len);
- ssh2_pkt_getstring(ssh, &lang, &lang_len);
+ ssh_pkt_getstring(ssh, &name, &name_len);
+ ssh_pkt_getstring(ssh, &inst, &inst_len);
+ ssh_pkt_getstring(ssh, &lang, &lang_len);
if (name_len > 0) {
c_write_untrusted(ssh, name, name_len);
c_write_str(ssh, "\r\n");
c_write_untrusted(ssh, inst, inst_len);
c_write_str(ssh, "\r\n");
}
- s->num_prompts = ssh2_pkt_getuint32(ssh);
+ s->num_prompts = ssh_pkt_getuint32(ssh);
}
/*
char *prompt;
int prompt_len;
- ssh2_pkt_getstring(ssh, &prompt, &prompt_len);
+ ssh_pkt_getstring(ssh, &prompt, &prompt_len);
if (prompt_len > 0) {
strncpy(s->pwprompt, prompt, sizeof(s->pwprompt));
s->pwprompt[prompt_len < sizeof(s->pwprompt) ?
* We have our passphrase. Now try the actual authentication.
*/
struct ssh2_userkey *key;
+ const char *error = NULL;
- key = ssh2_load_userkey(&ssh->cfg.keyfile, s->password);
+ key = ssh2_load_userkey(&ssh->cfg.keyfile, s->password,
+ &error);
if (key == SSH2_WRONG_PASSPHRASE || key == NULL) {
if (key == SSH2_WRONG_PASSPHRASE) {
c_write_str(ssh, "Wrong passphrase\r\n");
s->tried_pubkey_config = FALSE;
} else {
- c_write_str(ssh, "Unable to load private key\r\n");
+ c_write_str(ssh, "Unable to load private key (");
+ c_write_str(ssh, error);
+ c_write_str(ssh, ")\r\n");
s->tried_pubkey_config = TRUE;
}
/* Send a spurious AUTH_NONE to return to the top. */
ssh2_pkt_send(ssh);
s->type = AUTH_TYPE_PUBLICKEY;
+ key->alg->freekey(key->data);
}
} else if (s->method == AUTH_PASSWORD) {
/*
crStopV;
/* FIXME: error data comes back in FAILURE packet */
}
- if (ssh2_pkt_getuint32(ssh) != ssh->mainchan->localid) {
+ if (ssh_pkt_getuint32(ssh) != ssh->mainchan->localid) {
bombout(("Server's channel confirmation cited wrong channel"));
crStopV;
}
- ssh->mainchan->remoteid = ssh2_pkt_getuint32(ssh);
+ ssh->mainchan->remoteid = ssh_pkt_getuint32(ssh);
ssh->mainchan->type = CHAN_MAINSESSION;
ssh->mainchan->closes = 0;
- ssh->mainchan->v.v2.remwindow = ssh2_pkt_getuint32(ssh);
- ssh->mainchan->v.v2.remmaxpkt = ssh2_pkt_getuint32(ssh);
+ ssh->mainchan->v.v2.remwindow = ssh_pkt_getuint32(ssh);
+ ssh->mainchan->v.v2.remmaxpkt = ssh_pkt_getuint32(ssh);
bufchain_init(&ssh->mainchan->v.v2.outbuffer);
add234(ssh->channels, ssh->mainchan);
logevent("Opened channel for session");
do {
crWaitUntilV(ispkt);
if (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
- unsigned i = ssh2_pkt_getuint32(ssh);
+ unsigned i = ssh_pkt_getuint32(ssh);
struct ssh_channel *c;
c = find234(ssh->channels, &i, ssh_channelfind);
if (!c)
continue; /* nonexistent channel */
- c->v.v2.remwindow += ssh2_pkt_getuint32(ssh);
+ c->v.v2.remwindow += ssh_pkt_getuint32(ssh);
}
} while (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);
} else {
while (*ssh->portfwd_strptr) ssh->portfwd_strptr++;
dport = dserv = -1;
+ ssh->portfwd_strptr++; /* eat the NUL and move to next one */
}
sport = atoi(sports);
sserv = 0;
do {
crWaitUntilV(ispkt);
if (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
- unsigned i = ssh2_pkt_getuint32(ssh);
+ unsigned i = ssh_pkt_getuint32(ssh);
struct ssh_channel *c;
c = find234(ssh->channels, &i, ssh_channelfind);
if (!c)
continue;/* nonexistent channel */
- c->v.v2.remwindow += ssh2_pkt_getuint32(ssh);
+ c->v.v2.remwindow += ssh_pkt_getuint32(ssh);
}
} while (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);
do {
crWaitUntilV(ispkt);
if (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
- unsigned i = ssh2_pkt_getuint32(ssh);
+ unsigned i = ssh_pkt_getuint32(ssh);
struct ssh_channel *c;
c = find234(ssh->channels, &i, ssh_channelfind);
if (!c)
continue; /* nonexistent channel */
- c->v.v2.remwindow += ssh2_pkt_getuint32(ssh);
+ c->v.v2.remwindow += ssh_pkt_getuint32(ssh);
}
} while (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);
* Now allocate a pty for the session.
*/
if (!ssh->cfg.nopty) {
+ /* Unpick the terminal-speed string. */
+ /* XXX perhaps we should allow no speeds to be sent. */
+ ssh->ospeed = 38400; ssh->ispeed = 38400; /* last-resort defaults */
+ sscanf(ssh->cfg.termspeed, "%d,%d", &ssh->ospeed, &ssh->ispeed);
+ /* Build the pty request. */
ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_REQUEST);
ssh2_pkt_adduint32(ssh, ssh->mainchan->remoteid); /* recipient channel */
ssh2_pkt_addstring(ssh, "pty-req");
ssh2_pkt_adduint32(ssh, 0); /* pixel width */
ssh2_pkt_adduint32(ssh, 0); /* pixel height */
ssh2_pkt_addstring_start(ssh);
- ssh2_pkt_addstring_data(ssh, "\0", 1); /* TTY_OP_END, no special options */
+ ssh2_pkt_addbyte(ssh, 128); /* TTY_OP_ISPEED */
+ ssh2_pkt_adduint32(ssh, ssh->ispeed);
+ ssh2_pkt_addbyte(ssh, 129); /* TTY_OP_OSPEED */
+ ssh2_pkt_adduint32(ssh, ssh->ospeed);
+ ssh2_pkt_addstring_data(ssh, "\0", 1); /* TTY_OP_END */
ssh2_pkt_send(ssh);
ssh->state = SSH_STATE_INTERMED;
do {
crWaitUntilV(ispkt);
if (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
- unsigned i = ssh2_pkt_getuint32(ssh);
+ unsigned i = ssh_pkt_getuint32(ssh);
struct ssh_channel *c;
c = find234(ssh->channels, &i, ssh_channelfind);
if (!c)
continue; /* nonexistent channel */
- c->v.v2.remwindow += ssh2_pkt_getuint32(ssh);
+ c->v.v2.remwindow += ssh_pkt_getuint32(ssh);
}
} while (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);
c_write_str(ssh, "Server refused to allocate pty\r\n");
ssh->editing = ssh->echoing = 1;
} else {
- logevent("Allocated pty");
+ logeventf(ssh, "Allocated pty (ospeed %dbps, ispeed %dbps)",
+ ssh->ospeed, ssh->ispeed);
}
} else {
ssh->editing = ssh->echoing = 1;
do {
crWaitUntilV(ispkt);
if (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
- unsigned i = ssh2_pkt_getuint32(ssh);
+ unsigned i = ssh_pkt_getuint32(ssh);
struct ssh_channel *c;
c = find234(ssh->channels, &i, ssh_channelfind);
if (!c)
continue; /* nonexistent channel */
- c->v.v2.remwindow += ssh2_pkt_getuint32(ssh);
+ c->v.v2.remwindow += ssh_pkt_getuint32(ssh);
}
} while (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST);
if (ssh->pktin.type != SSH2_MSG_CHANNEL_SUCCESS) {
ssh->pktin.type == SSH2_MSG_CHANNEL_EXTENDED_DATA) {
char *data;
int length;
- unsigned i = ssh2_pkt_getuint32(ssh);
+ unsigned i = ssh_pkt_getuint32(ssh);
struct ssh_channel *c;
c = find234(ssh->channels, &i, ssh_channelfind);
if (!c)
continue; /* nonexistent channel */
if (ssh->pktin.type == SSH2_MSG_CHANNEL_EXTENDED_DATA &&
- ssh2_pkt_getuint32(ssh) != SSH2_EXTENDED_DATA_STDERR)
+ ssh_pkt_getuint32(ssh) != SSH2_EXTENDED_DATA_STDERR)
continue; /* extended but not stderr */
- ssh2_pkt_getstring(ssh, &data, &length);
+ ssh_pkt_getstring(ssh, &data, &length);
if (data) {
int bufsize = 0;
c->v.v2.locwindow -= length;
ssh2_set_window(c, OUR_V2_WINSIZE - bufsize);
}
} else if (ssh->pktin.type == SSH2_MSG_CHANNEL_EOF) {
- unsigned i = ssh2_pkt_getuint32(ssh);
+ unsigned i = ssh_pkt_getuint32(ssh);
struct ssh_channel *c;
c = find234(ssh->channels, &i, ssh_channelfind);
sshfwd_close(c);
}
} else if (ssh->pktin.type == SSH2_MSG_CHANNEL_CLOSE) {
- unsigned i = ssh2_pkt_getuint32(ssh);
+ unsigned i = ssh_pkt_getuint32(ssh);
struct ssh_channel *c;
c = find234(ssh->channels, &i, ssh_channelfind);
}
continue; /* remote sends close; ignore (FIXME) */
} else if (ssh->pktin.type == SSH2_MSG_CHANNEL_WINDOW_ADJUST) {
- unsigned i = ssh2_pkt_getuint32(ssh);
+ unsigned i = ssh_pkt_getuint32(ssh);
struct ssh_channel *c;
c = find234(ssh->channels, &i, ssh_channelfind);
if (!c || c->closes)
continue; /* nonexistent or closing channel */
- c->v.v2.remwindow += ssh2_pkt_getuint32(ssh);
+ c->v.v2.remwindow += ssh_pkt_getuint32(ssh);
s->try_send = TRUE;
} else if (ssh->pktin.type == SSH2_MSG_CHANNEL_OPEN_CONFIRMATION) {
- unsigned i = ssh2_pkt_getuint32(ssh);
+ unsigned i = ssh_pkt_getuint32(ssh);
struct ssh_channel *c;
c = find234(ssh->channels, &i, ssh_channelfind);
if (!c)
continue; /* nonexistent channel */
if (c->type != CHAN_SOCKDATA_DORMANT)
continue; /* dunno why they're confirming this */
- c->remoteid = ssh2_pkt_getuint32(ssh);
+ c->remoteid = ssh_pkt_getuint32(ssh);
c->type = CHAN_SOCKDATA;
- c->v.v2.remwindow = ssh2_pkt_getuint32(ssh);
- c->v.v2.remmaxpkt = ssh2_pkt_getuint32(ssh);
+ c->v.v2.remwindow = ssh_pkt_getuint32(ssh);
+ c->v.v2.remmaxpkt = ssh_pkt_getuint32(ssh);
if (c->u.pfd.s)
pfd_confirm(c->u.pfd.s);
if (c->closes) {
ssh2_pkt_send(ssh);
}
} else if (ssh->pktin.type == SSH2_MSG_CHANNEL_OPEN_FAILURE) {
- unsigned i = ssh2_pkt_getuint32(ssh);
+ unsigned i = ssh_pkt_getuint32(ssh);
struct ssh_channel *c;
c = find234(ssh->channels, &i, ssh_channelfind);
if (!c)
int typelen, want_reply;
struct ssh_channel *c;
- localid = ssh2_pkt_getuint32(ssh);
- ssh2_pkt_getstring(ssh, &type, &typelen);
+ localid = ssh_pkt_getuint32(ssh);
+ ssh_pkt_getstring(ssh, &type, &typelen);
want_reply = ssh2_pkt_getbool(ssh);
/*
c == ssh->mainchan) {
/* We recognise "exit-status" on the primary channel. */
char buf[100];
- ssh->exitcode = ssh2_pkt_getuint32(ssh);
+ ssh->exitcode = ssh_pkt_getuint32(ssh);
sprintf(buf, "Server sent command exit status %d",
ssh->exitcode);
logevent(buf);
char *type;
int typelen, want_reply;
- ssh2_pkt_getstring(ssh, &type, &typelen);
+ ssh_pkt_getstring(ssh, &type, &typelen);
want_reply = ssh2_pkt_getbool(ssh);
/*
char *error = NULL;
struct ssh_channel *c;
unsigned remid, winsize, pktsize;
- ssh2_pkt_getstring(ssh, &type, &typelen);
+ ssh_pkt_getstring(ssh, &type, &typelen);
c = snew(struct ssh_channel);
c->ssh = ssh;
- remid = ssh2_pkt_getuint32(ssh);
- winsize = ssh2_pkt_getuint32(ssh);
- pktsize = ssh2_pkt_getuint32(ssh);
+ remid = ssh_pkt_getuint32(ssh);
+ winsize = ssh_pkt_getuint32(ssh);
+ pktsize = ssh_pkt_getuint32(ssh);
if (typelen == 3 && !memcmp(type, "x11", 3)) {
char *addrstr;
- ssh2_pkt_getstring(ssh, &peeraddr, &peeraddrlen);
+ ssh_pkt_getstring(ssh, &peeraddr, &peeraddrlen);
addrstr = snewn(peeraddrlen+1, char);
memcpy(addrstr, peeraddr, peeraddrlen);
peeraddr[peeraddrlen] = '\0';
- peerport = ssh2_pkt_getuint32(ssh);
+ peerport = ssh_pkt_getuint32(ssh);
if (!ssh->X11_fwd_enabled)
error = "X11 forwarding is not enabled";
struct ssh_rportfwd pf, *realpf;
char *dummy;
int dummylen;
- ssh2_pkt_getstring(ssh, &dummy, &dummylen);/* skip address */
- pf.sport = ssh2_pkt_getuint32(ssh);
- ssh2_pkt_getstring(ssh, &peeraddr, &peeraddrlen);
- peerport = ssh2_pkt_getuint32(ssh);
+ ssh_pkt_getstring(ssh, &dummy, &dummylen);/* skip address */
+ pf.sport = ssh_pkt_getuint32(ssh);
+ ssh_pkt_getstring(ssh, &peeraddr, &peeraddrlen);
+ peerport = ssh_pkt_getuint32(ssh);
realpf = find234(ssh->rportfwds, &pf, NULL);
if (realpf == NULL) {
error = "Remote port is not recognised";
} else {
- char *e = pfd_newconnect(&c->u.pfd.s, realpf->dhost,
- realpf->dport, c, &ssh->cfg);
+ const char *e = pfd_newconnect(&c->u.pfd.s,
+ realpf->dhost,
+ realpf->dport, c,
+ &ssh->cfg);
logeventf(ssh, "Received remote port open request"
" for %s:%d", realpf->dhost, realpf->dport);
if (e != NULL) {
*
* Returns an error message, or NULL on success.
*/
-static char *ssh_init(void *frontend_handle, void **backend_handle,
- Config *cfg,
- char *host, int port, char **realhost, int nodelay)
+static const char *ssh_init(void *frontend_handle, void **backend_handle,
+ Config *cfg,
+ char *host, int port, char **realhost, int nodelay,
+ int keepalive)
{
- char *p;
+ const char *p;
Ssh ssh;
ssh = snew(struct ssh_tag);
ssh->protocol = NULL;
- p = connect_to_host(ssh, host, port, realhost, nodelay);
+ p = connect_to_host(ssh, host, port, realhost, nodelay, keepalive);
if (p != NULL)
return p;
ssh->csmac->free_context(ssh->cs_mac_ctx);
if (ssh->sc_mac_ctx)
ssh->scmac->free_context(ssh->sc_mac_ctx);
- if (ssh->cs_comp_ctx)
- ssh->cscomp->compress_cleanup(ssh->cs_comp_ctx);
- if (ssh->sc_comp_ctx)
- ssh->sccomp->compress_cleanup(ssh->sc_comp_ctx);
+ if (ssh->cs_comp_ctx) {
+ if (ssh->cscomp)
+ ssh->cscomp->compress_cleanup(ssh->cs_comp_ctx);
+ else
+ zlib_compress_cleanup(ssh->cs_comp_ctx);
+ }
+ if (ssh->sc_comp_ctx) {
+ if (ssh->sccomp)
+ ssh->sccomp->decompress_cleanup(ssh->sc_comp_ctx);
+ else
+ zlib_decompress_cleanup(ssh->sc_comp_ctx);
+ }
if (ssh->kex_ctx)
dh_cleanup(ssh->kex_ctx);
sfree(ssh->savedhost);
sfree(ssh->do_ssh1_login_state);
sfree(ssh->do_ssh2_transport_state);
sfree(ssh->do_ssh2_authconn_state);
-
+ if (ssh->pktout.data) {
+ sfree(ssh->pktout.data);
+ ssh->pktout.data = NULL;
+ }
+ if (ssh->pktin.data) {
+ sfree(ssh->pktin.data);
+ ssh->pktin.data = NULL;
+ }
+ if (ssh->crcda_ctx) {
+ crcda_free_context(ssh->crcda_ctx);
+ ssh->crcda_ctx = NULL;
+ }
+ if (ssh->logctx) {
+ log_free(ssh->logctx);
+ ssh->logctx = NULL;
+ }
if (ssh->s)
ssh_do_close(ssh);
sfree(ssh);
projects / u / mdw / putty / blobdiff