Introduce framework for authenticating with the local X server.

Windows and Mac backends have acquired auth-finding functions which
do nothing; Unix backend has acquired one which actually works, so
Plink can now do X forwarding believably.
(This checkin stretches into some unlikely parts of the code because
there have been one or two knock-on effects involving `const'. Bah.)

[originally from svn r2536]

unix/ux_x11.c

@@ -0,0 +1,106 @@
+/*
+ * ux_x11.c: fetch local auth data for X forwarding.
+ */
+
+#include <ctype.h>
+#include <unistd.h>
+#include "putty.h"
+
+void platform_get_x11_auth(char *display, int *protocol,
+                           unsigned char *data, int *datalen)
+{
+    FILE *fp;
+    char *command;
+    int maxsize = *datalen;
+    char *localbuf;
+
+    command = dupprintf("xauth list %s 2>/dev/null", display);
+    fp = popen(command, "r");
+    sfree(command);
+
+    if (!fp)
+        return;                        /* assume no auth */
+
+    localbuf = smalloc(maxsize);
+
+    while (1) {
+        /*
+         * Read a line from stdin, and attempt to parse it into a
+         * display name (ignored), auth protocol, and auth string.
+         */
+        int c, i, hexdigit, proto;
+        char protoname[64];
+
+        /* Skip the display name. */
+        while (c = getc(fp), c != EOF && c != '\n' && !isspace(c));
+        if (c == EOF) break;
+        if (c == '\n') continue;
+
+        /* Skip white space. */
+        while (c != EOF && c != '\n' && isspace(c))
+            c = getc(fp);
+        if (c == EOF) break;
+        if (c == '\n') continue;
+
+        /* Read the auth protocol name, and see if it matches any we
+         * know about. */
+        i = 0;
+        while (c != EOF && c != '\n' && !isspace(c)) {
+            if (i < lenof(protoname)-1) protoname[i++] = c;
+            c = getc(fp);
+        }
+        protoname[i] = '\0';
+
+        for (i = X11_NO_AUTH; ++i < X11_NAUTHS ;) {
+            if (!strcmp(protoname, x11_authnames[i]))
+                break;
+        }
+        if (i >= X11_NAUTHS || i <= proto) {
+            /* Unrecognised protocol name, or a worse one than we already have.
+	     * Skip this line. */
+            while (c != EOF && c != '\n')
+                c = getc(fp);
+            if (c == EOF) break;
+        }
+        proto = i;
+
+        /* Skip white space. */
+        while (c != EOF && c != '\n' && isspace(c))
+            c = getc(fp);
+        if (c == EOF) break;
+        if (c == '\n') continue;
+
+        /*
+         * Now grab pairs of hex digits and shove them into `data'.
+         */
+        i = 0;
+        hexdigit = -1;
+        while (c != EOF && c != '\n') {
+            int hexval = -1;
+            if (c >= 'A' && c <= 'F')
+                hexval = c + 10 - 'A';
+            if (c >= 'a' && c <= 'f')
+                hexval = c + 10 - 'a';
+            if (c >= '0' && c <= '9')
+                hexval = c - '0';
+            if (hexval >= 0) {
+                if (hexdigit >= 0) {
+                    hexdigit = (hexdigit << 4) + hexval;
+                    if (i < maxsize)
+                        localbuf[i++] = hexdigit;
+                    hexdigit = -1;
+                } else
+                    hexdigit = hexval;
+            }
+            c = getc(fp);
+        }
+
+        *datalen = i;
+        *protocol = proto;
+	memcpy(data, localbuf, i);
+
+	/* Nonetheless, continue looping round; we might find a better one. */
+    }
+    pclose(fp);
+    sfree(localbuf);
+}

unix/uxnet.c

@@ -298,8 +298,8 @@ static void sk_tcp_flush(Socket s)
 }
 
 static void sk_tcp_close(Socket s);
-static int sk_tcp_write(Socket s, char *data, int len);
-static int sk_tcp_write_oob(Socket s, char *data, int len);
+static int sk_tcp_write(Socket s, const char *data, int len);
+static int sk_tcp_write_oob(Socket s, const char *data, int len);
 static void sk_tcp_set_private_ptr(Socket s, void *ptr);
 static void *sk_tcp_get_private_ptr(Socket s);
 static void sk_tcp_set_frozen(Socket s, int is_frozen);
@@ -726,7 +726,7 @@ void try_send(Actual_Socket s)
     }
 }
 
-static int sk_tcp_write(Socket sock, char *buf, int len)
+static int sk_tcp_write(Socket sock, const char *buf, int len)
 {
     Actual_Socket s = (Actual_Socket) sock;
 
@@ -744,7 +744,7 @@ static int sk_tcp_write(Socket sock, char *buf, int len)
     return bufchain_size(&s->output_data);
 }
 
-static int sk_tcp_write_oob(Socket sock, char *buf, int len)
+static int sk_tcp_write_oob(Socket sock, const char *buf, int len)
 {
     Actual_Socket s = (Actual_Socket) sock;