#define translate(x) if (type == x) return #x
#define translatec(x,ctx) if (type == x && (pkt_ctx & ctx)) return #x
-char *ssh1_pkt_type(int type)
+static char *ssh1_pkt_type(int type)
{
translate(SSH1_MSG_DISCONNECT);
translate(SSH1_SMSG_PUBLIC_KEY);
translate(SSH1_CMSG_AUTH_CCARD_RESPONSE);
return "unknown";
}
-char *ssh2_pkt_type(int pkt_ctx, int type)
+static char *ssh2_pkt_type(int pkt_ctx, int type)
{
translate(SSH2_MSG_DISCONNECT);
translate(SSH2_MSG_IGNORE);
typedef struct ssh_tag *Ssh;
-extern char *x11_init(Socket *, char *, void *, void *);
-extern void x11_close(Socket);
-extern int x11_send(Socket, char *, int);
-extern void *x11_invent_auth(char *, int, char *, int);
-extern void x11_unthrottle(Socket s);
-extern void x11_override_throttle(Socket s, int enable);
-extern int x11_get_screen_number(char *display);
-
-extern char *pfd_newconnect(Socket * s, char *hostname, int port, void *c);
-extern char *pfd_addforward(char *desthost, int destport, char *srcaddr,
- int port, void *backhandle);
-extern void pfd_close(Socket s);
-extern int pfd_send(Socket s, char *data, int len);
-extern void pfd_confirm(Socket s);
-extern void pfd_unthrottle(Socket s);
-extern void pfd_override_throttle(Socket s, int enable);
-
static void ssh2_pkt_init(Ssh, int pkt_type);
static void ssh2_pkt_addbool(Ssh, unsigned char value);
static void ssh2_pkt_adduint32(Ssh, unsigned long value);
#define logevent(s) logevent(ssh->frontend, s)
/* logevent, only printf-formatted. */
-void logeventf(Ssh ssh, char *fmt, ...)
+static void logeventf(Ssh ssh, char *fmt, ...)
{
va_list ap;
char *buf;
s->i = -1;
} else if (s->i < sizeof(s->version) - 1)
s->version[s->i++] = c;
- } else if (c == '\n')
+ } else if (c == '\012')
break;
}
sha_string(&ssh->exhashbase, s->vstring, strcspn(s->vstring, "\r\n"));
sprintf(vlog, "We claim version: %s", verstring);
logevent(vlog);
- strcat(verstring, "\n");
+ strcat(verstring, "\012");
logevent("Using SSH protocol version 2");
sk_write(ssh->s, verstring, strlen(verstring));
ssh->protocol = ssh2_protocol;
sshver);
sprintf(vlog, "We claim version: %s", verstring);
logevent(vlog);
- strcat(verstring, "\n");
+ strcat(verstring, "\012");
logevent("Using SSH protocol version 1");
sk_write(ssh->s, verstring, strlen(verstring));
*/
logeventf(ssh, "Looking up host \"%s\"", host);
addr = name_lookup(host, port, realhost);
- if ((err = sk_addr_error(addr)))
+ if ((err = sk_addr_error(addr)) != NULL)
return err;
/*
}
ssh->fn = &fn_table;
ssh->s = new_connection(addr, *realhost, port, 0, 1, nodelay, (Plug) ssh);
- if ((err = sk_socket_error(ssh->s))) {
+ if ((err = sk_socket_error(ssh->s)) != NULL) {
ssh->s = NULL;
return err;
}
*/
/* Set up a username or password input loop on a given buffer. */
-void setup_userpass_input(Ssh ssh, char *buffer, int buflen, int echo)
+static void setup_userpass_input(Ssh ssh, char *buffer, int buflen, int echo)
{
ssh->userpass_input_buffer = buffer;
ssh->userpass_input_buflen = buflen;
* buffer), <0 for failure (user hit ^C/^D, bomb out and exit), 0
* for inconclusive (keep waiting for more input please).
*/
-int process_userpass_input(Ssh ssh, unsigned char *in, int inlen)
+static int process_userpass_input(Ssh ssh, unsigned char *in, int inlen)
{
char c;
char proto[20], data[64];
logevent("Requesting X11 forwarding");
ssh->x11auth = x11_invent_auth(proto, sizeof(proto),
- data, sizeof(data));
+ data, sizeof(data), cfg.x11_auth);
+ x11_get_real_auth(ssh->x11auth, cfg.x11_display);
if (ssh->v1_local_protoflags & SSH1_PROTOFLAG_SCREEN_NUMBER) {
send_packet(ssh, SSH1_CMSG_X11_REQUEST_FORWARDING,
PKT_STR, proto, PKT_STR, data,
c->ssh = ssh;
if (x11_init(&c->u.x11.s, cfg.x11_display, c,
- ssh->x11auth) != NULL) {
+ ssh->x11auth, NULL, -1) != NULL) {
logevent("opening X11 forward connection failed");
sfree(c);
send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
ssh2_pkt_addstring(ssh, "password");
ssh2_pkt_addbool(ssh, FALSE);
ssh2_pkt_addstring(ssh, s->password);
+ memset(s->password, 0, sizeof(s->password));
ssh2_pkt_defer(ssh);
/*
* We'll include a string that's an exact multiple of the
char proto[20], data[64];
logevent("Requesting X11 forwarding");
ssh->x11auth = x11_invent_auth(proto, sizeof(proto),
- data, sizeof(data));
+ data, sizeof(data), cfg.x11_auth);
+ x11_get_real_auth(ssh->x11auth, cfg.x11_display);
ssh2_pkt_init(ssh, SSH2_MSG_CHANNEL_REQUEST);
ssh2_pkt_adduint32(ssh, ssh->mainchan->remoteid);
ssh2_pkt_addstring(ssh, "x11-req");
unsigned i = ssh2_pkt_getuint32(ssh);
struct ssh_channel *c;
c = find234(ssh->channels, &i, ssh_channelfind);
- if (!c)
- continue; /* nonexistent channel */
+ if (!c || c->closes)
+ continue; /* nonexistent or closing channel */
c->v.v2.remwindow += ssh2_pkt_getuint32(ssh);
s->try_send = TRUE;
} else if (ssh->pktin.type == SSH2_MSG_CHANNEL_OPEN_CONFIRMATION) {
} else if (ssh->pktin.type == SSH2_MSG_CHANNEL_OPEN) {
char *type;
int typelen;
+ char *peeraddr;
+ int peeraddrlen;
+ int port;
char *error = NULL;
struct ssh_channel *c;
unsigned remid, winsize, pktsize;
remid = ssh2_pkt_getuint32(ssh);
winsize = ssh2_pkt_getuint32(ssh);
pktsize = ssh2_pkt_getuint32(ssh);
+ ssh2_pkt_getstring(ssh, &peeraddr, &peeraddrlen);
+ port = ssh2_pkt_getuint32(ssh);
if (typelen == 3 && !memcmp(type, "x11", 3)) {
+ char *addrstr = smalloc(peeraddrlen+1);
+ memcpy(addrstr, peeraddr, peeraddrlen);
+ peeraddr[peeraddrlen] = '\0';
+
if (!ssh->X11_fwd_enabled)
error = "X11 forwarding is not enabled";
else if (x11_init(&c->u.x11.s, cfg.x11_display, c,
- ssh->x11auth) != NULL) {
+ ssh->x11auth, addrstr, port) != NULL) {
error = "Unable to open an X11 connection";
} else {
c->type = CHAN_X11;
}
+
+ sfree(addrstr);
} else if (typelen == 15 &&
!memcmp(type, "forwarded-tcpip", 15)) {
struct ssh_rportfwd pf, *realpf;
* Try to send data on all channels if we can.
*/
for (i = 0; NULL != (c = index234(ssh->channels, i)); i++) {
- int bufsize = ssh2_try_send(c);
+ int bufsize;
+ if (c->closes)
+ continue; /* don't send on closing channels */
+ bufsize = ssh2_try_send(c);
if (bufsize == 0) {
switch (c->type) {
case CHAN_MAINSESSION:
ssh->overall_bufsize = 0;
ssh->fallback_cmd = 0;
+ ssh->protocol = NULL;
+
p = connect_to_host(ssh, host, port, realhost, nodelay);
if (p != NULL)
return p;
* This is called when stdout/stderr (the entity to which
* from_backend sends data) manages to clear some backlog.
*/
-void ssh_unthrottle(void *handle, int bufsize)
+static void ssh_unthrottle(void *handle, int bufsize)
{
Ssh ssh = (Ssh) handle;
if (ssh->version == 1) {