X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/51e9d3c00a3471f284e89ec1f59f38ca25f10c5f..HEAD:/x11fwd.c diff --git a/x11fwd.c b/x11fwd.c index 13c6823e..895d8a99 100644 --- a/x11fwd.c +++ b/x11fwd.c @@ -26,18 +26,11 @@ struct XDMSeen { unsigned char clientid[6]; }; -struct X11Auth { - unsigned char fakedata[64], realdata[64]; - int fakeproto, realproto; - int fakelen, reallen; - tree234 *xdmseen; -}; - struct X11Private { 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; + struct X11Display *disp; char *auth_protocol; unsigned char *auth_data; int data_read, auth_plen, auth_psize, auth_dlen, auth_dsize; @@ -57,86 +50,247 @@ static int xdmseen_cmp(void *a, void *b) memcmp(sa->clientid, sb->clientid, sizeof(sa->clientid)); } -void *x11_invent_auth(char *proto, int protomaxlen, - char *data, int datamaxlen, int proto_id) +/* Do-nothing "plug" implementation, used by x11_setup_display() when it + * creates a trial connection (and then immediately closes it). + * XXX: bit out of place here, could in principle live in a platform- + * independent network.c or something */ +static void dummy_plug_log(Plug p, int type, SockAddr addr, int port, + const char *error_msg, int error_code) { } +static int dummy_plug_closing + (Plug p, const char *error_msg, int error_code, int calling_back) +{ return 1; } +static int dummy_plug_receive(Plug p, int urgent, char *data, int len) +{ return 1; } +static void dummy_plug_sent(Plug p, int bufsize) { } +static int dummy_plug_accepting(Plug p, OSSocket sock) { return 1; } +static const struct plug_function_table dummy_plug = { + dummy_plug_log, dummy_plug_closing, dummy_plug_receive, + dummy_plug_sent, dummy_plug_accepting +}; + +struct X11Display *x11_setup_display(char *display, int authtype, Conf *conf) { - struct X11Auth *auth = snew(struct X11Auth); - char ourdata[64]; + struct X11Display *disp = snew(struct X11Display); + char *localcopy; int i; - if (proto_id == X11_MIT) { - auth->fakeproto = X11_MIT; + if (!display || !*display) { + localcopy = platform_get_x_display(); + if (!localcopy || !*localcopy) { + sfree(localcopy); + localcopy = dupstr(":0"); /* plausible default for any platform */ + } + } else + localcopy = dupstr(display); + + /* + * Parse the display name. + * + * We expect this to have one of the following forms: + * + * - the standard X format which looks like + * [ [ protocol '/' ] host ] ':' displaynumber [ '.' screennumber ] + * (X11 also permits a double colon to indicate DECnet, but + * that's not our problem, thankfully!) + * + * - only seen in the wild on MacOS (so far): a pathname to a + * Unix-domain socket, which will typically and confusingly + * end in ":0", and which I'm currently distinguishing from + * the standard scheme by noting that it starts with '/'. + */ + if (localcopy[0] == '/') { + disp->unixsocketpath = localcopy; + disp->unixdomain = TRUE; + disp->hostname = NULL; + disp->displaynum = -1; + disp->screennum = 0; + disp->addr = NULL; + } else { + char *colon, *dot, *slash; + char *protocol, *hostname; + + colon = strrchr(localcopy, ':'); + if (!colon) { + sfree(disp); + sfree(localcopy); + return NULL; /* FIXME: report a specific error? */ + } + + *colon++ = '\0'; + dot = strchr(colon, '.'); + if (dot) + *dot++ = '\0'; + + disp->displaynum = atoi(colon); + if (dot) + disp->screennum = atoi(dot); + else + disp->screennum = 0; + + protocol = NULL; + hostname = localcopy; + if (colon > localcopy) { + slash = strchr(localcopy, '/'); + if (slash) { + *slash++ = '\0'; + protocol = localcopy; + hostname = slash; + } + } + + disp->hostname = *hostname ? dupstr(hostname) : NULL; + + if (protocol) + disp->unixdomain = (!strcmp(protocol, "local") || + !strcmp(protocol, "unix")); + else if (!*hostname || !strcmp(hostname, "unix")) + disp->unixdomain = platform_uses_x11_unix_by_default; + else + disp->unixdomain = FALSE; + + if (!disp->hostname && !disp->unixdomain) + disp->hostname = dupstr("localhost"); + + disp->unixsocketpath = NULL; + disp->addr = NULL; + + sfree(localcopy); + } + + /* + * Look up the display hostname, if we need to. + */ + if (!disp->unixdomain) { + const char *err; + + disp->port = 6000 + disp->displaynum; + disp->addr = name_lookup(disp->hostname, disp->port, + &disp->realhost, conf, ADDRTYPE_UNSPEC); + + if ((err = sk_addr_error(disp->addr)) != NULL) { + sk_addr_free(disp->addr); + sfree(disp->hostname); + sfree(disp->unixsocketpath); + sfree(disp); + return NULL; /* FIXME: report an error */ + } + } + + /* + * Try upgrading an IP-style localhost display to a Unix-socket + * display (as the standard X connection libraries do). + */ + if (!disp->unixdomain && sk_address_is_local(disp->addr)) { + SockAddr ux = platform_get_x11_unix_address(NULL, disp->displaynum); + const char *err = sk_addr_error(ux); + if (!err) { + /* Create trial connection to see if there is a useful Unix-domain + * socket */ + const struct plug_function_table *dummy = &dummy_plug; + Socket s = sk_new(sk_addr_dup(ux), 0, 0, 0, 0, 0, (Plug)&dummy); + err = sk_socket_error(s); + sk_close(s); + } + if (err) { + sk_addr_free(ux); + } else { + sk_addr_free(disp->addr); + disp->unixdomain = TRUE; + disp->addr = ux; + /* Fill in the rest in a moment */ + } + } + + if (disp->unixdomain) { + if (!disp->addr) + disp->addr = platform_get_x11_unix_address(disp->unixsocketpath, + disp->displaynum); + if (disp->unixsocketpath) + disp->realhost = dupstr(disp->unixsocketpath); + else + disp->realhost = dupprintf("unix:%d", disp->displaynum); + disp->port = 0; + } + + /* + * Invent the remote authorisation details. + */ + if (authtype == X11_MIT) { + disp->remoteauthproto = X11_MIT; /* MIT-MAGIC-COOKIE-1. Cookie size is 128 bits (16 bytes). */ - auth->fakelen = 16; + disp->remoteauthdata = snewn(16, unsigned char); for (i = 0; i < 16; i++) - auth->fakedata[i] = random_byte(); - auth->xdmseen = NULL; + disp->remoteauthdata[i] = random_byte(); + disp->remoteauthdatalen = 16; + + disp->xdmseen = NULL; } else { - assert(proto_id == X11_XDM); - auth->fakeproto = X11_XDM; + assert(authtype == X11_XDM); + disp->remoteauthproto = X11_XDM; /* XDM-AUTHORIZATION-1. Cookie size is 16 bytes; byte 8 is zero. */ - auth->fakelen = 16; + disp->remoteauthdata = snewn(16, unsigned char); for (i = 0; i < 16; i++) - auth->fakedata[i] = (i == 8 ? 0 : random_byte()); - auth->xdmseen = newtree234(xdmseen_cmp); + disp->remoteauthdata[i] = (i == 8 ? 0 : random_byte()); + disp->remoteauthdatalen = 16; + + disp->xdmseen = newtree234(xdmseen_cmp); } + disp->remoteauthprotoname = dupstr(x11_authnames[disp->remoteauthproto]); + disp->remoteauthdatastring = snewn(disp->remoteauthdatalen * 2 + 1, char); + for (i = 0; i < disp->remoteauthdatalen; i++) + sprintf(disp->remoteauthdatastring + i*2, "%02x", + disp->remoteauthdata[i]); - /* Now format for the recipient. */ - strncpy(proto, x11_authnames[auth->fakeproto], protomaxlen); - ourdata[0] = '\0'; - for (i = 0; i < auth->fakelen; i++) - sprintf(ourdata + strlen(ourdata), "%02x", auth->fakedata[i]); - strncpy(data, ourdata, datamaxlen); + /* + * Fetch the local authorisation details. + */ + disp->localauthproto = X11_NO_AUTH; + disp->localauthdata = NULL; + disp->localauthdatalen = 0; + platform_get_x11_auth(disp, conf); - return auth; + return disp; } -void x11_free_auth(void *authv) +void x11_free_display(struct X11Display *disp) { - struct X11Auth *auth = (struct X11Auth *)authv; - struct XDMSeen *seen; - - if (auth->xdmseen != NULL) { - while ((seen = delpos234(auth->xdmseen, 0)) != NULL) + if (disp->xdmseen != NULL) { + struct XDMSeen *seen; + while ((seen = delpos234(disp->xdmseen, 0)) != NULL) sfree(seen); - freetree234(auth->xdmseen); + freetree234(disp->xdmseen); } - sfree(auth); -} - -/* - * Fetch the real auth data for a given display string, and store - * it in an X11Auth structure. Returns NULL on success, or an error - * string. - */ -void x11_get_real_auth(void *authv, char *display) -{ - struct X11Auth *auth = (struct X11Auth *)authv; - - auth->realproto = X11_NO_AUTH; /* in case next call does nothing */ - - auth->reallen = sizeof(auth->realdata); - platform_get_x11_auth(display, &auth->realproto, - auth->realdata, &auth->reallen); + sfree(disp->hostname); + sfree(disp->unixsocketpath); + if (disp->localauthdata) + smemclr(disp->localauthdata, disp->localauthdatalen); + sfree(disp->localauthdata); + if (disp->remoteauthdata) + smemclr(disp->remoteauthdata, disp->remoteauthdatalen); + sfree(disp->remoteauthdata); + sfree(disp->remoteauthprotoname); + sfree(disp->remoteauthdatastring); + sk_addr_free(disp->addr); + sfree(disp); } #define XDM_MAXSKEW 20*60 /* 20 minute clock skew should be OK */ static char *x11_verify(unsigned long peer_ip, int peer_port, - struct X11Auth *auth, char *proto, + struct X11Display *disp, char *proto, unsigned char *data, int dlen) { - if (strcmp(proto, x11_authnames[auth->fakeproto]) != 0) - return "wrong authentication protocol attempted"; - if (auth->fakeproto == X11_MIT) { - if (dlen != auth->fakelen) + if (strcmp(proto, x11_authnames[disp->remoteauthproto]) != 0) + return "wrong authorisation protocol attempted"; + if (disp->remoteauthproto == X11_MIT) { + if (dlen != disp->remoteauthdatalen) return "MIT-MAGIC-COOKIE-1 data was wrong length"; - if (memcmp(auth->fakedata, data, dlen) != 0) + if (memcmp(disp->remoteauthdata, data, dlen) != 0) return "MIT-MAGIC-COOKIE-1 data did not match"; } - if (auth->fakeproto == X11_XDM) { + if (disp->remoteauthproto == X11_XDM) { unsigned long t; time_t tim; int i; @@ -146,8 +300,8 @@ static char *x11_verify(unsigned long peer_ip, int peer_port, return "XDM-AUTHORIZATION-1 data was wrong length"; if (peer_port == -1) return "cannot do XDM-AUTHORIZATION-1 without remote address data"; - des_decrypt_xdmauth(auth->fakedata+9, data, 24); - if (memcmp(auth->fakedata, data, 8) != 0) + des_decrypt_xdmauth(disp->remoteauthdata+9, data, 24); + if (memcmp(disp->remoteauthdata, data, 8) != 0) return "XDM-AUTHORIZATION-1 data failed check"; /* cookie wrong */ if (GET_32BIT_MSB_FIRST(data+8) != peer_ip) return "XDM-AUTHORIZATION-1 data failed check"; /* IP wrong */ @@ -163,25 +317,184 @@ static char *x11_verify(unsigned long peer_ip, int peer_port, seen = snew(struct XDMSeen); seen->time = t; memcpy(seen->clientid, data+8, 6); - assert(auth->xdmseen != NULL); - ret = add234(auth->xdmseen, seen); + assert(disp->xdmseen != NULL); + ret = add234(disp->xdmseen, seen); if (ret != seen) { sfree(seen); return "XDM-AUTHORIZATION-1 data replayed"; } /* While we're here, purge entries too old to be replayed. */ for (;;) { - seen = index234(auth->xdmseen, 0); + seen = index234(disp->xdmseen, 0); assert(seen != NULL); if (t - seen->time <= XDM_MAXSKEW) break; - sfree(delpos234(auth->xdmseen, 0)); + sfree(delpos234(disp->xdmseen, 0)); } } /* implement other protocols here if ever required */ return NULL; } +void x11_get_auth_from_authfile(struct X11Display *disp, + const char *authfilename) +{ + FILE *authfp; + char *buf, *ptr, *str[4]; + int len[4]; + int family, protocol; + int ideal_match = FALSE; + char *ourhostname; + + /* + * Normally we should look for precisely the details specified in + * `disp'. However, there's an oddity when the display is local: + * displays like "localhost:0" usually have their details stored + * in a Unix-domain-socket record (even if there isn't actually a + * real Unix-domain socket available, as with OpenSSH's proxy X11 + * server). + * + * This is apparently a fudge to get round the meaninglessness of + * "localhost" in a shared-home-directory context -- xauth entries + * for Unix-domain sockets already disambiguate this by storing + * the *local* hostname in the conveniently-blank hostname field, + * but IP "localhost" records couldn't do this. So, typically, an + * IP "localhost" entry in the auth database isn't present and if + * it were it would be ignored. + * + * However, we don't entirely trust that (say) Windows X servers + * won't rely on a straight "localhost" entry, bad idea though + * that is; so if we can't find a Unix-domain-socket entry we'll + * fall back to an IP-based entry if we can find one. + */ + int localhost = !disp->unixdomain && sk_address_is_local(disp->addr); + + authfp = fopen(authfilename, "rb"); + if (!authfp) + return; + + ourhostname = get_hostname(); + + /* Records in .Xauthority contain four strings of up to 64K each */ + buf = snewn(65537 * 4, char); + + while (!ideal_match) { + int c, i, j, match = FALSE; + +#define GET do { c = fgetc(authfp); if (c == EOF) goto done; c = (unsigned char)c; } while (0) + /* Expect a big-endian 2-byte number giving address family */ + GET; family = c; + GET; family = (family << 8) | c; + /* Then expect four strings, each composed of a big-endian 2-byte + * length field followed by that many bytes of data */ + ptr = buf; + for (i = 0; i < 4; i++) { + GET; len[i] = c; + GET; len[i] = (len[i] << 8) | c; + str[i] = ptr; + for (j = 0; j < len[i]; j++) { + GET; *ptr++ = c; + } + *ptr++ = '\0'; + } +#undef GET + + /* + * Now we have a full X authority record in memory. See + * whether it matches the display we're trying to + * authenticate to. + * + * The details we've just read should be interpreted as + * follows: + * + * - 'family' is the network address family used to + * connect to the display. 0 means IPv4; 6 means IPv6; + * 256 means Unix-domain sockets. + * + * - str[0] is the network address itself. For IPv4 and + * IPv6, this is a string of binary data of the + * appropriate length (respectively 4 and 16 bytes) + * representing the address in big-endian format, e.g. + * 7F 00 00 01 means IPv4 localhost. For Unix-domain + * sockets, this is the host name of the machine on + * which the Unix-domain display resides (so that an + * .Xauthority file on a shared file system can contain + * authority entries for Unix-domain displays on + * several machines without them clashing). + * + * - str[1] is the display number. I've no idea why + * .Xauthority stores this as a string when it has a + * perfectly good integer format, but there we go. + * + * - str[2] is the authorisation method, encoded as its + * canonical string name (i.e. "MIT-MAGIC-COOKIE-1", + * "XDM-AUTHORIZATION-1" or something we don't + * recognise). + * + * - str[3] is the actual authorisation data, stored in + * binary form. + */ + + if (disp->displaynum < 0 || disp->displaynum != atoi(str[1])) + continue; /* not the one */ + + for (protocol = 1; protocol < lenof(x11_authnames); protocol++) + if (!strcmp(str[2], x11_authnames[protocol])) + break; + if (protocol == lenof(x11_authnames)) + continue; /* don't recognise this protocol, look for another */ + + switch (family) { + case 0: /* IPv4 */ + if (!disp->unixdomain && + sk_addrtype(disp->addr) == ADDRTYPE_IPV4) { + char buf[4]; + sk_addrcopy(disp->addr, buf); + if (len[0] == 4 && !memcmp(str[0], buf, 4)) { + match = TRUE; + /* If this is a "localhost" entry, note it down + * but carry on looking for a Unix-domain entry. */ + ideal_match = !localhost; + } + } + break; + case 6: /* IPv6 */ + if (!disp->unixdomain && + sk_addrtype(disp->addr) == ADDRTYPE_IPV6) { + char buf[16]; + sk_addrcopy(disp->addr, buf); + if (len[0] == 16 && !memcmp(str[0], buf, 16)) { + match = TRUE; + ideal_match = !localhost; + } + } + break; + case 256: /* Unix-domain / localhost */ + if ((disp->unixdomain || localhost) + && ourhostname && !strcmp(ourhostname, str[0])) + /* A matching Unix-domain socket is always the best + * match. */ + match = ideal_match = TRUE; + break; + } + + if (match) { + /* Current best guess -- may be overridden if !ideal_match */ + disp->localauthproto = protocol; + sfree(disp->localauthdata); /* free previous guess, if any */ + disp->localauthdata = snewn(len[3], unsigned char); + memcpy(disp->localauthdata, str[3], len[3]); + disp->localauthdatalen = len[3]; + } + } + + done: + fclose(authfp); + smemclr(buf, 65537 * 4); + sfree(buf); + sfree(ourhostname); +} + static void x11_log(Plug p, int type, SockAddr addr, int port, const char *error_msg, int error_code) { @@ -193,13 +506,20 @@ static int x11_closing(Plug plug, const char *error_msg, int error_code, { struct X11Private *pr = (struct X11Private *) plug; - /* - * We have no way to communicate down the forwarded connection, - * so if an error occurred on the socket, we just ignore it - * and treat it like a proper close. - */ - sshfwd_close(pr->c); - x11_close(pr->s); + if (error_msg) { + /* + * Socket error. Slam the connection instantly shut. + */ + sshfwd_unclean_close(pr->c); + } else { + /* + * Ordinary EOF received on socket. Send an EOF on the SSH + * channel. + */ + if (pr->c) + sshfwd_write_eof(pr->c); + } + return 1; } @@ -240,33 +560,14 @@ int x11_get_screen_number(char *display) return atoi(display + n + 1); } -/* Find the right display, returns an allocated string */ -char *x11_display(const char *display) { - char *ret; - if(!display || !*display) { - /* try to find platform-specific local display */ - if((ret = platform_get_x_display())==0) - /* plausible default for all platforms */ - ret = dupstr(":0"); - } else - ret = dupstr(display); - if(ret[0] == ':') { - /* no transport specified, use whatever we think is best */ - char *s = dupcat(platform_x11_best_transport, ret, (char *)0); - sfree(ret); - return s; - } else - return ret; -} - /* * Called to set up the raw connection. * * Returns an error message, or NULL on success. * also, fills the SocketsStructure */ -const char *x11_init(Socket * s, char *display, void *c, void *auth, - const char *peeraddr, int peerport, const Config *cfg) +extern const char *x11_init(Socket *s, struct X11Display *disp, void *c, + const char *peeraddr, int peerport, Conf *conf) { static const struct plug_function_table fn_table = { x11_log, @@ -276,63 +577,24 @@ const char *x11_init(Socket * s, char *display, void *c, void *auth, NULL }; - SockAddr addr; - int port; const char *err; - char *dummy_realhost; - char host[128]; - int n, displaynum; struct X11Private *pr; - /* default display */ - display = x11_display(display); - /* - * Split up display name into host and display-number parts. - */ - n = strcspn(display, ":"); - assert(n != 0); /* x11_display() promises this */ - if (display[n]) - displaynum = atoi(display + n + 1); - else - displaynum = 0; /* sensible default */ - if (n > sizeof(host) - 1) - n = sizeof(host) - 1; - strncpy(host, display, n); - host[n] = '\0'; - sfree(display); - - if(!strcmp(host, "unix")) { - /* use AF_UNIX sockets (doesn't make sense on all platforms) */ - addr = platform_get_x11_unix_address(displaynum, - &dummy_realhost); - port = 0; /* to show we are not confused */ - } else { - port = 6000 + displaynum; - - /* - * Try to find host. - */ - addr = name_lookup(host, port, &dummy_realhost, cfg, ADDRTYPE_UNSPEC); - if ((err = sk_addr_error(addr)) != NULL) { - sk_addr_free(addr); - return err; - } - } - /* * Open socket. */ pr = snew(struct X11Private); pr->fn = &fn_table; pr->auth_protocol = NULL; - pr->auth = (struct X11Auth *)auth; + pr->disp = disp; pr->verified = 0; pr->data_read = 0; pr->throttled = pr->throttle_override = 0; pr->c = c; - pr->s = *s = new_connection(addr, dummy_realhost, port, - 0, 1, 0, 0, (Plug) pr, cfg); + pr->s = *s = new_connection(sk_addr_dup(disp->addr), + disp->realhost, disp->port, + 0, 1, 0, 0, (Plug) pr, conf); if ((err = sk_socket_error(*s)) != NULL) { sfree(pr); return err; @@ -439,18 +701,18 @@ int x11_send(Socket s, char *data, int len) return 0; /* - * If we haven't verified the authentication, do so now. + * If we haven't verified the authorisation, do so now. */ if (!pr->verified) { char *err; pr->auth_protocol[pr->auth_plen] = '\0'; /* ASCIZ */ err = x11_verify(pr->peer_ip, pr->peer_port, - pr->auth, pr->auth_protocol, + pr->disp, pr->auth_protocol, pr->auth_data, pr->auth_dlen); /* - * If authentication failed, construct and send an error + * If authorisation failed, construct and send an error * packet, then terminate the connection. */ if (err) { @@ -458,7 +720,7 @@ int x11_send(Socket s, char *data, int len) int msglen, msgsize; unsigned char *reply; - message = dupprintf("PuTTY X11 proxy: %s", err); + message = dupprintf("%s X11 proxy: %s", appname, err); msglen = strlen(message); reply = snewn(8 + msglen+1 + 4, unsigned char); /* include zero */ msgsize = (msglen + 3) & ~3; @@ -469,8 +731,7 @@ int x11_send(Socket s, char *data, int len) memset(reply + 8, 0, msgsize); memcpy(reply + 8, message, msglen); sshfwd_write(pr->c, (char *)reply, 8 + msgsize); - sshfwd_close(pr->c); - x11_close(s); + sshfwd_write_eof(pr->c); sfree(reply); sfree(message); return 0; @@ -484,27 +745,27 @@ int x11_send(Socket s, char *data, int len) { char realauthdata[64]; int realauthlen = 0; - int authstrlen = strlen(x11_authnames[pr->auth->realproto]); - int buflen; + int authstrlen = strlen(x11_authnames[pr->disp->localauthproto]); + int buflen = 0; /* initialise to placate optimiser */ static const char zeroes[4] = { 0,0,0,0 }; void *buf; - if (pr->auth->realproto == X11_MIT) { - assert(pr->auth->reallen <= lenof(realauthdata)); - realauthlen = pr->auth->reallen; - memcpy(realauthdata, pr->auth->realdata, realauthlen); - } else if (pr->auth->realproto == X11_XDM && - pr->auth->reallen == 16 && + if (pr->disp->localauthproto == X11_MIT) { + assert(pr->disp->localauthdatalen <= lenof(realauthdata)); + realauthlen = pr->disp->localauthdatalen; + memcpy(realauthdata, pr->disp->localauthdata, realauthlen); + } else if (pr->disp->localauthproto == X11_XDM && + pr->disp->localauthdatalen == 16 && ((buf = sk_getxdmdata(s, &buflen))!=0)) { time_t t; realauthlen = (buflen+12+7) & ~7; assert(realauthlen <= lenof(realauthdata)); memset(realauthdata, 0, realauthlen); - memcpy(realauthdata, pr->auth->realdata, 8); + memcpy(realauthdata, pr->disp->localauthdata, 8); memcpy(realauthdata+8, buf, buflen); t = time(NULL); PUT_32BIT_MSB_FIRST(realauthdata+8+buflen, t); - des_encrypt_xdmauth(pr->auth->realdata+9, + des_encrypt_xdmauth(pr->disp->localauthdata+9, (unsigned char *)realauthdata, realauthlen); sfree(buf); @@ -517,7 +778,8 @@ int x11_send(Socket s, char *data, int len) sk_write(s, (char *)pr->firstpkt, 12); if (authstrlen) { - sk_write(s, x11_authnames[pr->auth->realproto], authstrlen); + sk_write(s, x11_authnames[pr->disp->localauthproto], + authstrlen); sk_write(s, zeroes, 3 & (-authstrlen)); } if (realauthlen) { @@ -534,3 +796,8 @@ int x11_send(Socket s, char *data, int len) return sk_write(s, data, len); } + +void x11_send_eof(Socket s) +{ + sk_write_eof(s); +}