Move to AF_UNIX listener instead of socat usage

Mark Dietzer · benpye · commit f1bdb88ef9f6 · 2018-07-04T15:12:01.000+01:00
diff --git a/Program.cs b/Program.cs
@@ -1,4 +1,5 @@
 using System;
+using System.IO;
 using System.Net;
 using System.Net.Sockets;
 using System.Runtime.InteropServices;
@@ -79,7 +80,7 @@ struct COPYDATASTRUCT
     static readonly IntPtr AGENT_COPYDATA_ID = new IntPtr(0x804e50ba);
 
     // Send ssh-agent query to Pageant, ssh-agent and Pageant use same messages
-    static byte[] Query(byte[] buf)
+    static byte[] Query(byte[] buf, int buflen)
     {
         var hwnd = FindWindowByCaption(IntPtr.Zero, "Pageant");
 
@@ -89,17 +90,17 @@ static byte[] Query(byte[] buf)
 
         var sharedMemory = MapViewOfFile(fileMap, FileMapAccess.FileMapWrite, 0, 0, UIntPtr.Zero);
 
-        Marshal.Copy(buf, 0, sharedMemory, buf.Length);
+        Marshal.Copy(buf, 0, sharedMemory, buflen);
 
         var cds = new COPYDATASTRUCT();
         cds.dwData = AGENT_COPYDATA_ID;
         cds.cbData = mapName.Length + 1;
-        var foo = Encoding.UTF8.GetBytes(mapName);
-        var bar = new byte[foo.Length + 1];
-        foo.CopyTo(bar, 0);
-        bar[bar.Length - 1] = 0;
-        var gch = GCHandle.Alloc(bar);
-        cds.lpData = Marshal.UnsafeAddrOfPinnedArrayElement(bar, 0);
+        var mapNameBytes = Encoding.UTF8.GetBytes(mapName);
+        var mapNameBytesZero = new byte[mapNameBytes.Length + 1];
+        mapNameBytes.CopyTo(mapNameBytesZero, 0);
+        mapNameBytesZero[mapNameBytesZero.Length - 1] = 0;
+        var gch = GCHandle.Alloc(mapNameBytesZero);
+        cds.lpData = Marshal.UnsafeAddrOfPinnedArrayElement(mapNameBytesZero, 0);
         var data = Marshal.AllocHGlobal(Marshal.SizeOf(cds));
         Marshal.StructureToPtr(cds, data, false);
         var rcode = SendMessage(hwnd, WM_COPYDATA, IntPtr.Zero, data);
@@ -117,21 +118,98 @@ static byte[] Query(byte[] buf)
         return ret;
     }
 
+    private static void Callback(Task<Socket> t, object state)
+    {
+        var client = t.Result;
+        client.ReceiveTimeout = 1000;
+        client.SendTimeout = 1000;
+
+        try
+        {
+            ServiceSocket(client);
+        }
+        catch (TimeoutException)
+        {
+            // Ignore timeouts, those should not explode our stuff
+        }
+        catch (SocketException e)
+        {
+            // Other socket errors can happen and shouldn't kill the app
+            Console.Error.WriteLine(e);
+        }
+
+        client.Dispose();
+    }
+
+    private static bool ReadUntil(Socket client, byte[] buf, int buflen, int offset = 0)
+    {
+        int i;
+        while ((i = client.Receive(buf, offset, buflen - offset, SocketFlags.None)) != 0)
+        {
+            offset += i;
+            if (offset >= buflen)
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static void ServiceSocket(Socket client)
+    {
+        var lenBytes = new byte[4]; // uint32
+
+        while (true)
+        {
+            // Read length as uint32 (4 bytes)
+            if (!ReadUntil(client, lenBytes, lenBytes.Length))
+            {
+                break;
+            }
+            var len = (lenBytes[0] << 24) |
+                      (lenBytes[1] << 16) |
+                      (lenBytes[2] << 8 ) |
+                      (lenBytes[3]);
+
+            // Read actual data and copy length to the start of it
+            var bytes = new byte[4 + len];
+            lenBytes.CopyTo(bytes, 0);
+            if (!ReadUntil(client, bytes, bytes.Length, 4))
+            {
+                break;
+            }
+
+            var msg = Query(bytes, bytes.Length);
+            client.Send(msg, 0, msg.Length, SocketFlags.None);
+        }
+    }
+
     static void Main(string[] args)
     {
-        var outstream = Console.OpenStandardOutput();
-        var instream  = Console.OpenStandardInput();
+        var socketPath = @".\ssh-agent.sock";
 
-        int i;
+        if (args.Length == 1)
+            socketPath = args[0];
+        else if(args.Length != 0)
+        {
+            Console.WriteLine(@"wsl-ssh-agent.exe <path: .\ssh-agent.sock>");
+            return;
+        }
+
+        File.Delete(socketPath);
+        var server = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.IP);
+        server.Bind(new UnixEndPoint(socketPath));
+        server.Listen(5);
 
-        // Buffer for reading data
-        var bytes = new Byte[AGENT_MAX_MSGLEN];
+        Console.WriteLine(@"Listening on {0}", socketPath);
 
-        // Loop to receive all the data sent by the client.
-        while((i = instream.Read(bytes, 0, bytes.Length))!=0)
+        // Enter the listening loop.
+        while(true)
         {
-            var msg = Query(bytes);
-            outstream.Write(msg, 0, msg.Length);
+            var t = server.AcceptAsync();
+            t.ContinueWith(Callback, null);
+            t.Wait();
         }
     }
 }
+
diff --git a/Readme.md b/Readme.md
@@ -1,24 +1,21 @@
 # wsl-ssh-pageant
 
-**Now supports multiple ssh connections concurrently!**
-
-A Pageant -> TCP bridge for use with WSL, allowing for Pageant to be used as an ssh-ageant within the WSL environment.
-
-Also check out [NZSmartie's Go version](https://github.com/NZSmartie/wsl-ssh-pageant).
-
-![Demo](demo.gif?raw=True)
+**Now uses freshly baked AF_UNIX support in Windows 10 insider**
 
 ## How to use
 
 1. On the Windows side run Pageant (or compatible agent such as gpg4win).
 
-2. Ensure that the directory containing `wsl-ssh-pageant.exe` is on the `PATH` in WSL, for example my path contains `/mnt/c/git/wsl-ssh-pageant'
+2. Run wsl-ssh-pageant.exe on windows in a short path (max ~100 characters total!)
 
 3. In WSL run the following
 
 ```
-$ socat UNIX-LISTEN:/tmp/wsl-ssh-pageant.socket,unlink-close,unlink-early,fork EXEC:"wsl-ssh-pageant.exe" &
-$ export SSH_AUTH_SOCK=/tmp/wsl-ssh-pageant.socket
+$ export SSH_AUTH_SOCK=/mnt/your-path-to-wsl-ssh-pageant.exe/ssh-agent.sock
+```
+For example, if you have wsl-ssh-pageant.exe in `C:\wsl-ssh-pageant`
+```
+$ export SSH_AUTH_SOCK=/mnt/c/wsl-ssh-pageant/ssh-agent.sock
 ```
 
 4. The SSH keys from Pageant should now be usable by `ssh`!
diff --git a/UnixEndPoint.cs b/UnixEndPoint.cs
@@ -0,0 +1,144 @@
+﻿using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+
+// copied from https://github.com/mono/mono/blob/master/mcs/class/Mono.Posix/Mono.Unix/UnixEndPoint.cs
+// modified by Mark "Doridian" Dietzer to work with AF_UNIX on win32 [requires 108 / UNIX_PATH_MAX size struct and fixes for RemoteEndPoint due to that]
+
+//
+// Mono.Unix.UnixEndPoint: EndPoint derived class for AF_UNIX family sockets.
+//
+// Authors:
+//  Gonzalo Paniagua Javier (gonzalo@ximian.com)
+//
+// (C) 2003 Ximian, Inc (http://www.ximian.com)
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+
+public class UnixEndPoint : EndPoint
+{
+    string filename;
+
+    const int UNIX_PATH_MAX = 108;
+
+    public UnixEndPoint(string filename)
+    {
+        if (filename == null)
+            throw new ArgumentNullException("filename");
+
+        if (filename == "")
+            throw new ArgumentException("Cannot be empty.", "filename");
+
+        this.filename = filename;
+    }
+
+    public string Filename
+    {
+        get
+        {
+            return (filename);
+        }
+        set
+        {
+            filename = value;
+        }
+    }
+
+    public override AddressFamily AddressFamily
+    {
+        get { return AddressFamily.Unix; }
+    }
+
+    public override EndPoint Create(SocketAddress socketAddress)
+    {
+        /*
+         * Should also check this
+         *
+        int addr = (int) AddressFamily.Unix;
+        if (socketAddress [0] != (addr & 0xFF))
+            throw new ArgumentException ("socketAddress is not a unix socket address.");
+        if (socketAddress [1] != ((addr & 0xFF00) >> 8))
+            throw new ArgumentException ("socketAddress is not a unix socket address.");
+         */
+
+        int size = socketAddress.Size - 2;
+        byte[] bytes = new byte[size];
+        for (int i = 0; i < bytes.Length; i++)
+        {
+            bytes[i] = socketAddress[i + 2];
+            // There may be junk after the null terminator, so ignore it all.
+            if (bytes[i] == 0)
+            {
+                size = i;
+                break;
+            }
+        }
+
+        if (size == 0)
+        {
+            // Empty filename.
+            // Probably from RemoteEndPoint which on linux does not return the file name.
+            UnixEndPoint uep = new UnixEndPoint("a");
+            uep.filename = "";
+            return uep;
+        }
+
+        string name = Encoding.UTF8.GetString(bytes, 0, size);
+        return new UnixEndPoint(name);
+    }
+
+    public override SocketAddress Serialize()
+    {
+        byte[] bytes = Encoding.UTF8.GetBytes(filename);
+        SocketAddress sa = new SocketAddress(AddressFamily, 2 + UNIX_PATH_MAX);
+        // sa [0] -> family low byte, sa [1] -> family high byte
+        for (int i = 0; i < bytes.Length; i++)
+            sa[2 + i] = bytes[i];
+
+        //NULL suffix for non-abstract path
+        sa[2 + bytes.Length] = 0;
+
+        return sa;
+    }
+
+    public override string ToString()
+    {
+        return (filename);
+    }
+
+    public override int GetHashCode()
+    {
+        return filename.GetHashCode();
+    }
+
+    public override bool Equals(object o)
+    {
+        UnixEndPoint other = o as UnixEndPoint;
+        if (other == null)
+            return false;
+
+        return (other.filename == filename);
+    }
+}
