csharp support

.gitignore

@@ -1,3 +1,7 @@
 TODO
 typescript/dist 
-demos/groktunnel/groktunnel
+demos/groktunnel/groktunnel
+
+**/*/bin
+**/*/obj
+**/*/.DS_Store

csharp/Makefile

@@ -0,0 +1,14 @@
+build_qmux: 
+	dotnet build ./qmux/qmux.csproj
+build_gostdlib:
+	dotnet build ./gostdlib/gostdlib.csproj
+build: build_qmux
+test: 
+	dotnet test ./qmux.tests/qmux.tests.csproj
+test_gostdlib:
+	dotnet test ./gostdlib.tests/gostdlib.tests.csproj
+clean_src: 
+	dotnet clean ./qmux/qmux.csproj
+clean_test: 
+	dotnet clean ./qmux.tests/qmux.tests.csproj
+clean: clean_src clean_test

csharp/README.md

@@ -0,0 +1,34 @@
+# qmux for C#
+
+> WIP
+
+## Setup
+
+`qmux` for C# requires `dotnet`. Install `dotnet` manually or via package
+manager using instructions below.
+
+### Package Manager Installation
+
+| Platform | Command                      |
+| -------- | ---------------------------- |
+| macos    | `brew install dotnet --cask` |
+| win11    | `choco install dotnet`       |
+| win11    | `winget install dotnet`      |
+| apt      | `apt install dotnet`         |
+
+### Manual Installation
+
+Download the `dotnet` installer
+[for your platform here](https://dotnet.microsoft.com/en-us/download).
+
+## Build
+
+```bash
+dotnet build ./qmux/qmux.csproj
+```
+
+## Run tests
+
+```bash
+dotnet test ./qmux.tests/qmux.tests.csproj
+```

csharp/gostdlib.tests/gostdlib.tests.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="3.1.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\gostdlib\gostdlib.csproj" />
+  </ItemGroup>
+
+</Project>

csharp/gostdlib/README.md

@@ -0,0 +1,3 @@
+# go
+
+Go types used in the qmux csharp implementation.

csharp/gostdlib/context/context.cs

@@ -0,0 +1,97 @@
+namespace gostdlib.context;
+
+public interface IContext
+{
+    // Deadline returns the time when work done on behalf of this context
+    // should be canceled. Deadline returns ok==false when no deadline is
+    // set. Successive calls to Deadline return the same results.
+    public (string, bool) Deadline();
+
+    // Done returns a channel that's closed when work done on behalf of this
+    // context should be canceled. Done may return nil if this context can
+    // never be canceled. Successive calls to Done return the same value.
+    // The close of the Done channel may happen asynchronously,
+    // after the cancel function returns.
+    //
+    // WithCancel arranges for Done to be closed when cancel is called;
+    // WithDeadline arranges for Done to be closed when the deadline
+    // expires; WithTimeout arranges for Done to be closed when the timeout
+    // elapses.
+    //
+    // Done is provided for use in select statements:
+    //
+    //  // Stream generates values with DoSomething and sends them to out
+    //  // until DoSomething returns an error or ctx.Done is closed.
+    //  func Stream(ctx context.Context, out chan<- Value) error {
+    //  	for {
+    //  		v, err := DoSomething(ctx)
+    //  		if err != nil {
+    //  			return err
+    //  		}
+    //  		select {
+    //  		case <-ctx.Done():
+    //  			return ctx.Err()
+    //  		case out <- v:
+    //  		}
+    //  	}
+    //  }
+    //
+    // See https://blog.golang.org/pipelines for more examples of how to use
+    // a Done channel for cancellation.
+    // Done() < -chan struct{ }
+
+    // If Done is not yet closed, Err returns nil.
+    // If Done is closed, Err returns a non-nil error explaining why:
+    // Canceled if the context was canceled
+    // or DeadlineExceeded if the context's deadline passed.
+    // After Err returns a non-nil error, successive calls to Err return the same error.
+    // Err() error
+
+    // Value returns the value associated with this context for key, or nil
+    // if no value is associated with key. Successive calls to Value with
+    // the same key returns the same result.
+    //
+    // Use context values only for request-scoped data that transits
+    // processes and API boundaries, not for passing optional parameters to
+    // functions.
+    //
+    // A key identifies a specific value in a Context. Functions that wish
+    // to store values in Context typically allocate a key in a global
+    // variable then use that key as the argument to context.WithValue and
+    // Context.Value. A key can be any type that supports equality;
+    // packages should define keys as an unexported type to avoid
+    // collisions.
+    //
+    // Packages that define a Context key should provide type-safe accessors
+    // for the values stored using that key:
+    //
+    // 	// Package user defines a User type that's stored in Contexts.
+    // 	package user
+    //
+    // 	import "context"
+    //
+    // 	// User is the type of value stored in the Contexts.
+    // 	type User struct {...}
+    //
+    // 	// key is an unexported type for keys defined in this package.
+    // 	// This prevents collisions with keys defined in other packages.
+    // 	type key int
+    //
+    // 	// userKey is the key for user.User values in Contexts. It is
+    // 	// unexported; clients use user.NewContext and user.FromContext
+    // 	// instead of using this key directly.
+    // 	var userKey key
+    //
+    // 	// NewContext returns a new Context that carries value u.
+    // 	func NewContext(ctx context.Context, u *User) context.Context {
+    // 		return context.WithValue(ctx, userKey, u)
+    // 	}
+    //
+    // 	// FromContext returns the User value stored in ctx, if any.
+    // 	func FromContext(ctx context.Context) (*User, bool) {
+    // 		u, ok := ctx.Value(userKey).(*User)
+    // 		return u, ok
+    // 	}
+    // Value(key interface{ }) interface{ }
+    object Value(object key);
+}

csharp/gostdlib/errors/errors.cs

@@ -0,0 +1,92 @@
+namespace gostdlib.errors;
+
+public static partial class errors
+{
+    public class Error
+    {
+        private string errorString;
+
+        public Error(string errorString)
+        {
+            this.errorString = errorString;
+        }
+
+        public override string ToString()
+        {
+            return $"{this.errorString}";
+        }
+    }
+
+    // Copyright 2011 The Go Authors. All rights reserved.
+    // Use of this source code is governed by a BSD-style
+    // license that can be found in the LICENSE file.
+
+    // Package errors implements functions to manipulate errors.
+    //
+    // The New function creates errors whose only content is a text message.
+    //
+    // The Unwrap, Is and As functions work on errors that may wrap other errors.
+    // An error wraps another error if its type has the method
+    //
+    //	Unwrap() error
+    //
+    // If e.Unwrap() returns a non-nil error w, then we say that e wraps w.
+    //
+    // Unwrap unpacks wrapped errors. If its argument's type has an
+    // Unwrap method, it calls the method once. Otherwise, it returns nil.
+    //
+    // A simple way to create wrapped errors is to call fmt.Errorf and apply the %w verb
+    // to the error argument:
+    //
+    //	errors.Unwrap(fmt.Errorf("... %w ...", ..., err, ...))
+    //
+    // returns err.
+    //
+    // Is unwraps its first argument sequentially looking for an error that matches the
+    // second. It reports whether it finds a match. It should be used in preference to
+    // simple equality checks:
+    //
+    //	if errors.Is(err, fs.ErrExist)
+    //
+    // is preferable to
+    //
+    //	if err == fs.ErrExist
+    //
+    // because the former will succeed if err wraps fs.ErrExist.
+    //
+    // As unwraps its first argument sequentially looking for an error that can be
+    // assigned to its second argument, which must be a pointer. If it succeeds, it
+    // performs the assignment and returns true. Otherwise, it returns false. The form
+    //
+    //	var perr *fs.PathError
+    //	if errors.As(err, &perr) {
+    //		fmt.Println(perr.Path)
+    //	}
+    //
+    // is preferable to
+    //
+    //	if perr, ok := err.(*fs.PathError); ok {
+    //		fmt.Println(perr.Path)
+    //	}
+    //
+    // because the former will succeed if err wraps an *fs.PathError.
+    // package errors
+
+    // New returns an error that formats as the given text.
+    // Each call to New returns a distinct error value even if the text is identical.
+
+    // func New(text string) error {
+    // 	return &errorString{text}
+    // }
+
+    // // errorString is a trivial implementation of error.
+    // type errorString struct {
+
+    //     s string
+    // }
+
+    // func(e * errorString) Error() string
+    // {
+    //     return e.s
+    // }
+}

csharp/gostdlib/gostdlib.csproj

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

csharp/gostdlib/io/io.cs

@@ -0,0 +1,23 @@
+namespace gostdlib.io;
+using gostdlib.errors;
+public static partial class io
+{
+    public interface IWriteCloser : IWriter, ICloser { }
+    public interface IReadCloser : IReader, ICloser { }
+    public interface IWriter
+    {
+        public int Write(byte[] p);
+    }
+
+    public interface IReader
+    {
+        public (int, errors.Error?) Read(byte[] p);
+    }
+
+    public interface ICloser
+    {
+        public void Close();
+    }
+
+    public static errors.Error EOF = new errors.Error("EOF");
+}

csharp/qmux.tests/codec/message_close_test.cs

@@ -0,0 +1,22 @@
+namespace qmux.tests.codec;
+
+using Xunit;
+
+using qmux.codec;
+
+public class TestCloseMessage
+{
+    [Fact]
+    public void Test_CloseMessage_MarshalUnmarshalMuxRoundtrip()
+    {
+        var msg1 = new codec.CloseMessage()
+        {
+            ChannelId = 10,
+        };
+
+        var marshaled = msg1.MarshalMux();
+        var msg2 = new codec.CloseMessage();
+        msg2.UnmarshalMux(marshaled);
+        Assert.Equal(msg1.ChannelId, msg2.ChannelId);
+    }
+}

csharp/qmux.tests/codec/message_data_test.cs

@@ -0,0 +1,26 @@
+namespace qmux.tests.codec;
+
+using Xunit;
+
+using qmux.codec;
+
+public class TestDataMessage
+{
+    [Fact]
+    public void Test_DataMessage_MarshalUnmarshalMuxRoundtrip()
+    {
+        var msg1 = new codec.DataMessage()
+        {
+            ChannelId = 10,
+            Length = 5,
+            Data = new byte[5] { 0x20, 0x20, 0x20, 0x20, 0x20 },
+        };
+
+        var marshaled = msg1.MarshalMux();
+        var msg2 = new codec.DataMessage();
+        msg2.UnmarshalMux(marshaled);
+        Assert.Equal(msg1.ChannelId, msg2.ChannelId);
+        Assert.Equal(msg1.Length, msg2.Length);
+        Assert.Equal(msg1.Data, msg2.Data);
+    }
+}

csharp/qmux.tests/codec/message_eof_test.cs

@@ -0,0 +1,22 @@
+namespace qmux.tests.codec;
+
+using Xunit;
+
+using qmux.codec;
+
+public class TestEofMessage
+{
+    [Fact]
+    public void Test_EofMessage_MarshalUnmarshalMuxRoundtrip()
+    {
+        var msg1 = new codec.EofMessage()
+        {
+            ChannelId = 10,
+        };
+
+        var marshaled = msg1.MarshalMux();
+        var msg2 = new codec.EofMessage();
+        msg2.UnmarshalMux(marshaled);
+        Assert.Equal(msg1.ChannelId, msg2.ChannelId);
+    }
+}