How to connect to a Unix Domain Socket in .NET Core in C#

using System.Net.Sockets;

var unixSocketName = "/var/run/mysqld/mysqld.sock";
var unixSocket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.IP);
unixSocket.Connect(new UnixDomainSocketEndPoint(unixSocketName));

Because I couldn't find a good example for unix sockets I designed my own. Its very rudementary and has not many errorcatching, but it works.

Here it is:

using System;
using System.Net.Sockets;
using System.Threading;

namespace mps.unix.socket
{

    public class UnixSocket
    {
        private Socket recvSocket;
        private string unixSocketpath;  // needed for cleanup
        private bool running = true;
        private byte[] data = new byte[0];

        public UnixSocket(string unixSocket)
        {
            this.unixSocketpath = unixSocket;
            this.recvSocket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified);

            System.IO.File.Delete(unixSocketpath);
            var ep = new UnixDomainSocketEndPoint(unixSocketpath);
            recvSocket.Bind(ep);

            recvSocket.Listen();

            Thread w = new Thread(worker);
            w.Start();
        }

        private void worker()
        {
            while (this.running)
            {
                try
                {
                    var clientSocket = this.recvSocket.Accept();                        // waits for 'client' to 'connect'

                    Thread t = new Thread(delegate () { clientWorker(clientSocket); });
                    t.Start();
                }
                catch (Exception) { }
            }
        }

        private void clientWorker(Socket s)
        {
            while (running)
            {
                byte[] d = new byte[s.ReceiveBufferSize];

                int length = s.Receive(d);

                lock (this.data)
                {
                    byte[] newData = new byte[this.data.Length + length];
                    Buffer.BlockCopy(this.data, 0, newData, 0, this.data.Length);
                    Buffer.BlockCopy(d, 0, newData, this.data.Length, length);

                    this.data = newData;
                }
            }

            s.Close();
        }

        public bool isRunning()
        {
            return this.running;
        }

        public void Stop()
        {
            this.running = false;
            Thread.Sleep(10);
            this.recvSocket.Close();
            System.IO.File.Delete(this.unixSocketpath);
        }

        public bool hasData()
        {
            return this.data.Length > 0;
        }

        public int dataLength()
        {
            lock (this.data)
                return this.data.Length;
        }

        public byte[] getData()
        {
            lock (this.data)
            {
                var d = this.data;
                this.data = new byte[0];

                return d;
            }
        }

        public byte[] getData(int length)
        {
            lock (this.data)
            {
                if (this.data.Length < length)
                    return this.getData();

                //var d = this.data.Take(length).ToArray();
                //var rest = new byte[0];

                byte[] taken = new byte[length];
                byte[] rest = new byte[this.data.Length - length];

                Buffer.BlockCopy(this.data, 0, taken, 0, length);
                Buffer.BlockCopy(this.data, length, rest, 0, rest.Length);

                this.data = rest;

                return taken;
            }
        }
    }
}

Here is a litte program where you can see how to use the class:

using System;
using System.Threading;
using mps.unix.socket;


namespace TEST_mps.unix.socket
{
    class Program { static void Main(string[] args) { var P = new TEST(); } }

    class TEST
    {
        public TEST()
        {
            var v = new UnixSocket("/tmp/test.mps.unix.sock");

            Thread t = new Thread(delegate () { runner(v); });
            t.Start();
        }

        private void runner(UnixSocket s)
        {
            while (s.isRunning())
            {
                Thread.Sleep(5);

                if (s.hasData())
                {
                    string responseData = System.Text.Encoding.ASCII.GetString(s.getData());
                    Console.WriteLine("Message received: {0}", responseData);

                    if (responseData == "END")
                        s.Stop();
                }
            }
        }
    }
}

I compiled this with .Net 6.0 for linux-x64.

For testing run the software and then send something to the socket:

On server:

root@server:# ./test.mps.unix.socket
Message received: this is a message for the socket!
Message received: here is another one..
Message received: END
root@server:#

From another shell:

root@server:# echo -n 'this is a message for the socket!' | socat UNIX-CONNECT:/tmp/test.mps.unix.sock STDIO
root@server:# echo -n 'here is another one..' | socat UNIX-CONNECT:/tmp/test.mps.unix.sock STDIO
root@server:# echo -n 'END' | socat UNIX-CONNECT:/tmp/test.mps.unix.sock STDIO

If you found bugs or can make improvements tell me and I will see if we can add it to the example :)