X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/d74d141c2daed084c8a62c5dc5b88e801b81ee5a..b7a189f38294c745ae4ea6efb55891c8196e275b:/x11fwd.c diff --git a/x11fwd.c b/x11fwd.c index b13f695f..35d1d175 100644 --- a/x11fwd.c +++ b/x11fwd.c @@ -1,17 +1,9 @@ -#include #include #include #include "putty.h" #include "ssh.h" -#ifndef FALSE -#define FALSE 0 -#endif -#ifndef TRUE -#define TRUE 1 -#endif - #define GET_32BIT_LSB_FIRST(cp) \ (((unsigned long)(unsigned char)(cp)[0]) | \ ((unsigned long)(unsigned char)(cp)[1] << 8) | \ @@ -58,52 +50,57 @@ #define PUT_16BIT(endian, cp, val) \ (endian=='B' ? PUT_16BIT_MSB_FIRST(cp, val) : PUT_16BIT_LSB_FIRST(cp, val)) -extern void sshfwd_close(void *); -extern void sshfwd_write(void *, char *, int); +struct X11Auth { + unsigned char data[64]; + int len; +}; struct X11Private { - struct plug_function_table *fn; + const struct plug_function_table *fn; /* the above variable absolutely *must* be the first in this structure */ unsigned char firstpkt[12]; /* first X data packet */ + struct X11Auth *auth; char *auth_protocol; unsigned char *auth_data; int data_read, auth_plen, auth_psize, auth_dlen, auth_dsize; int verified; + int throttled, throttle_override; void *c; /* data used by ssh.c */ Socket s; }; void x11_close(Socket s); -static unsigned char x11_authdata[64]; -static int x11_authdatalen; - -void x11_invent_auth(char *proto, int protomaxlen, +void *x11_invent_auth(char *proto, int protomaxlen, char *data, int datamaxlen) { + struct X11Auth *auth = smalloc(sizeof(struct X11Auth)); char ourdata[64]; int i; /* MIT-MAGIC-COOKIE-1. Cookie size is 128 bits (16 bytes). */ - x11_authdatalen = 16; + auth->len = 16; for (i = 0; i < 16; i++) - x11_authdata[i] = random_byte(); + auth->data[i] = random_byte(); /* Now format for the recipient. */ strncpy(proto, "MIT-MAGIC-COOKIE-1", protomaxlen); ourdata[0] = '\0'; - for (i = 0; i < x11_authdatalen; i++) - sprintf(ourdata + strlen(ourdata), "%02x", x11_authdata[i]); + for (i = 0; i < auth->len; i++) + sprintf(ourdata + strlen(ourdata), "%02x", auth->data[i]); strncpy(data, ourdata, datamaxlen); + + return auth; } -static int x11_verify(char *proto, unsigned char *data, int dlen) +static int x11_verify(struct X11Auth *auth, + char *proto, unsigned char *data, int dlen) { if (strcmp(proto, "MIT-MAGIC-COOKIE-1") != 0) return 0; /* wrong protocol attempted */ - if (dlen != x11_authdatalen) + if (dlen != auth->len) return 0; /* cookie was wrong length */ - if (memcmp(x11_authdata, data, dlen) != 0) + if (memcmp(auth->data, data, dlen) != 0) return 0; /* cookie was wrong cookie! */ return 1; } @@ -127,21 +124,34 @@ static int x11_receive(Plug plug, int urgent, char *data, int len) { struct X11Private *pr = (struct X11Private *) plug; - sshfwd_write(pr->c, data, len); + if (sshfwd_write(pr->c, data, len) > 0) { + pr->throttled = 1; + sk_set_frozen(pr->s, 1); + } + return 1; } +static void x11_sent(Plug plug, int bufsize) +{ + struct X11Private *pr = (struct X11Private *) plug; + + sshfwd_unthrottle(pr->c, bufsize); +} + /* * Called to set up the raw connection. * * Returns an error message, or NULL on success. * also, fills the SocketsStructure */ -char *x11_init(Socket * s, char *display, void *c) +char *x11_init(Socket * s, char *display, void *c, void *auth) { - static struct plug_function_table fn_table = { + static const struct plug_function_table fn_table = { x11_closing, - x11_receive + x11_receive, + x11_sent, + NULL }; SockAddr addr; @@ -167,7 +177,7 @@ char *x11_init(Socket * s, char *display, void *c) /* * Try to find host. */ - addr = sk_namelookup(host, &dummy_realhost); + addr = name_lookup(host, port, &dummy_realhost); if ((err = sk_addr_error(addr))) return err; @@ -179,11 +189,13 @@ char *x11_init(Socket * s, char *display, void *c) pr = (struct X11Private *) smalloc(sizeof(struct X11Private)); pr->fn = &fn_table; pr->auth_protocol = NULL; + pr->auth = (struct X11Auth *)auth; pr->verified = 0; pr->data_read = 0; + pr->throttled = pr->throttle_override = 0; pr->c = c; - pr->s = *s = sk_new(addr, port, 0, 1, (Plug) pr); + pr->s = *s = new_connection(addr, dummy_realhost, port, 0, 1, 0, (Plug) pr); if ((err = sk_socket_error(*s))) { sfree(pr); return err; @@ -210,15 +222,37 @@ void x11_close(Socket s) sk_close(s); } +void x11_unthrottle(Socket s) +{ + struct X11Private *pr; + if (!s) + return; + pr = (struct X11Private *) sk_get_private_ptr(s); + + pr->throttled = 0; + sk_set_frozen(s, pr->throttled || pr->throttle_override); +} + +void x11_override_throttle(Socket s, int enable) +{ + struct X11Private *pr; + if (!s) + return; + pr = (struct X11Private *) sk_get_private_ptr(s); + + pr->throttle_override = enable; + sk_set_frozen(s, pr->throttled || pr->throttle_override); +} + /* * Called to send data down the raw connection. */ -void x11_send(Socket s, char *data, int len) +int x11_send(Socket s, char *data, int len) { struct X11Private *pr = (struct X11Private *) sk_get_private_ptr(s); if (s == NULL) - return; + return 0; /* * Read the first packet. @@ -226,7 +260,7 @@ void x11_send(Socket s, char *data, int len) while (len > 0 && pr->data_read < 12) pr->firstpkt[pr->data_read++] = (unsigned char) (len--, *data++); if (pr->data_read < 12) - return; + return 0; /* * If we have not allocated the auth_protocol and auth_data @@ -251,7 +285,7 @@ void x11_send(Socket s, char *data, int len) pr->auth_data[pr->data_read++ - 12 - pr->auth_psize] = (unsigned char) (len--, *data++); if (pr->data_read < 12 + pr->auth_psize + pr->auth_dsize) - return; + return 0; /* * If we haven't verified the authentication, do so now. @@ -260,7 +294,8 @@ void x11_send(Socket s, char *data, int len) int ret; pr->auth_protocol[pr->auth_plen] = '\0'; /* ASCIZ */ - ret = x11_verify(pr->auth_protocol, pr->auth_data, pr->auth_dlen); + ret = x11_verify(pr->auth, pr->auth_protocol, + pr->auth_data, pr->auth_dlen); /* * If authentication failed, construct and send an error @@ -274,13 +309,13 @@ void x11_send(Socket s, char *data, int len) reply[0] = 0; /* failure */ reply[1] = msglen; /* length of reason string */ memcpy(reply + 2, pr->firstpkt + 2, 4); /* major/minor proto vsn */ - PUT_16BIT(pr->firstpkt[0], reply + 6, msglen >> 2); /* data len */ + PUT_16BIT(pr->firstpkt[0], reply + 6, msgsize >> 2);/* data len */ memset(reply + 8, 0, msgsize); memcpy(reply + 8, message, msglen); sshfwd_write(pr->c, reply, 8 + msgsize); sshfwd_close(pr->c); x11_close(s); - return; + return 0; } /* @@ -298,5 +333,5 @@ void x11_send(Socket s, char *data, int len) * After initialisation, just copy data simply. */ - sk_write(s, data, len); + return sk_write(s, data, len); }