feat(toyirc): add SAM IRC integration client

Connect through IVNP to irc.postman.i2p and verify registration plus PING/PONG handling in CI.

Author: lemon-mint

.github/workflows/irc2p.yml

@@ -0,0 +1,93 @@
+name: irc2p tunnel integration
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  irc2p:
+    runs-on: ubuntu-latest
+    timeout-minutes: 8
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+          cache: true
+      - name: Build daemon
+        shell: bash
+        run: go build -o "$RUNNER_TEMP/ivnpd" ./cmd/ivnpd
+      - name: Run real tunnel and IRC connection
+        shell: bash
+        run: |
+          set -euo pipefail
+          readonly run_dir="$RUNNER_TEMP/ivnp-irc2p"
+          mkdir -p -- "$run_dir"
+          curl --fail --location --silent --show-error --retry 3 --retry-all-errors \
+            --output "$run_dir/privatehosts.txt" \
+            https://raw.githubusercontent.com/i2p/i2p.i2p/master/installer/resources/hosts.txt
+          cat >"$run_dir/ivnp.conf" <<EOF
+          [router]
+          version = 0.9.70
+          [tunnel]
+          enabled = true
+          hops = 2
+          exploratory_inbound_target = 1
+          exploratory_outbound_target = 1
+          exploratory_pool_capacity = 2
+          client_inbound_target = 1
+          client_outbound_target = 1
+          client_pool_capacity = 2
+          build_pending_capacity = 13
+          lifetime = 10m
+          renew_before = 30s
+          maintenance_interval = 1s
+          [sam]
+          enabled = true
+          listen_host = 127.0.0.1
+          listen_port = 7656
+          [addressbook]
+          enabled = true
+          privatehosts_path = $run_dir/privatehosts.txt
+          subscriptions =
+          [log]
+          level = info
+          format = text
+          EOF
+          "$RUNNER_TEMP/ivnpd" -config "$run_dir/ivnp.conf" -webui=false >"$run_dir/ivnpd.log" 2>&1 &
+          daemon_pid=$!
+          cleanup() {
+            status=$?
+            trap - EXIT
+            kill "$daemon_pid" 2>/dev/null || true
+            wait "$daemon_pid" 2>/dev/null || true
+            if ((status != 0)); then
+              cat "$run_dir/ivnpd.log" >&2
+            fi
+            exit "$status"
+          }
+          trap cleanup EXIT
+          ready=false
+          for _ in {1..90}; do
+            if (exec 3<>/dev/tcp/127.0.0.1/7656) 2>/dev/null; then
+              exec 3>&-
+              ready=true
+              break
+            fi
+            if ! kill -0 "$daemon_pid" 2>/dev/null; then
+              printf 'ivnpd exited before SAM became ready\n' >&2
+              exit 1
+            fi
+            sleep 1
+          done
+          if [[ $ready != true ]]; then
+            printf 'SAM did not become ready\n' >&2
+            exit 1
+          fi
+          IVNP_IRC2P_INTEGRATION=1 IVNP_IRC2P_SAM=127.0.0.1:7656 \
+            go test ./cmd/toyirc -run '^TestIRC2PIntegration$' -count=1 -timeout=5m

cmd/toyirc/main.go

@@ -0,0 +1,204 @@
+package main
+
+import (
+	"bufio"
+	"context"
+	"crypto/rand"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"net"
+	"os"
+	"os/signal"
+	"strconv"
+	"strings"
+	"time"
+
+	"gosuda.org/ivnp/client"
+	"gosuda.org/ivnp/foundation"
+)
+
+const maxRunTime = 5 * time.Minute
+
+type ircConfig struct {
+	samAddress string
+	server     string
+	port       int
+	nick       string
+}
+
+func main() {
+	var timeout time.Duration
+	config := ircConfig{}
+	flag.StringVar(&config.samAddress, "sam", "127.0.0.1:7656", "SAM bridge address")
+	flag.StringVar(&config.server, "server", "irc.postman.i2p", "IRC I2P hostname or destination")
+	flag.IntVar(&config.port, "port", 6667, "IRC destination port")
+	flag.StringVar(&config.nick, "nick", "", "IRC nickname")
+	flag.DurationVar(&timeout, "timeout", maxRunTime, "overall connection timeout")
+	flag.Parse()
+	if timeout <= 0 || timeout > maxRunTime {
+		fmt.Fprintln(os.Stderr, "timeout must be between 1ns and 5m")
+		os.Exit(2)
+	}
+	if config.nick == "" {
+		nick, err := randomNick()
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+		config.nick = nick
+	}
+	parent, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer stop()
+	ctx, cancel := context.WithTimeout(parent, timeout)
+	defer cancel()
+	if err := runIRC2P(ctx, config, os.Stdout); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func runIRC2P(ctx context.Context, config ircConfig, output io.Writer) error {
+	if ctx == nil || config.samAddress == "" || config.server == "" {
+		return errors.New("toyirc: invalid configuration")
+	}
+	if config.port < 1 || config.port > 65535 || !validNick(config.nick) {
+		return errors.New("toyirc: invalid configuration")
+	}
+	address := net.JoinHostPort(config.server, strconv.Itoa(config.port))
+	var lastErr error
+	for {
+		attemptContext, cancel := context.WithTimeout(ctx, 90*time.Second)
+		lastErr = runIRC2PAttempt(attemptContext, config, address)
+		cancel()
+		if lastErr == nil {
+			_, err := fmt.Fprintf(output, "connected to %s as %s\n", address, config.nick)
+			return err
+		}
+		if ctx.Err() != nil {
+			return fmt.Errorf("toyirc: connect %s: %w", address, errors.Join(ctx.Err(), lastErr))
+		}
+		timer := time.NewTimer(2 * time.Second)
+		select {
+		case <-ctx.Done():
+			timer.Stop()
+			return fmt.Errorf("toyirc: connect %s: %w", address, errors.Join(ctx.Err(), lastErr))
+		case <-timer.C:
+		}
+	}
+}
+
+func runIRC2PAttempt(ctx context.Context, config ircConfig, address string) error {
+	network, err := client.SimpleAnonymousMessagingNew(client.SimpleAnonymousMessagingConfig{
+		Address: config.samAddress, SignatureType: foundation.SigningEdDSASHA512Ed25519,
+		LeaseSetEncTypes: []foundation.CryptoKeyType{foundation.CryptoX25519},
+	})
+	if err != nil {
+		return fmt.Errorf("toyirc: create SAM session: %w", err)
+	}
+	defer network.Close()
+	if err = network.Start(ctx); err != nil {
+		return fmt.Errorf("toyirc: start SAM session: %w", err)
+	}
+	connection, err := network.DialI2P(ctx, address)
+	if err != nil {
+		return fmt.Errorf("toyirc: connect %s: %w", address, err)
+	}
+	defer connection.Close()
+	return exchangeIRC(ctx, connection, config.nick)
+}
+
+func exchangeIRC(ctx context.Context, connection net.Conn, nick string) error {
+	if ctx == nil || connection == nil || !validNick(nick) {
+		return errors.New("toyirc: invalid IRC connection")
+	}
+	if deadline, ok := ctx.Deadline(); ok {
+		if err := connection.SetDeadline(deadline); err != nil {
+			return err
+		}
+	}
+	stop := context.AfterFunc(ctx, func() { _ = connection.SetDeadline(time.Now()) })
+	defer stop()
+	if err := writeIRC(connection, "NICK "+nick); err != nil {
+		return fmt.Errorf("toyirc: send NICK: %w", err)
+	}
+	if err := writeIRC(connection, "USER "+nick+" 0 * :IVNP integration client"); err != nil {
+		return fmt.Errorf("toyirc: send USER: %w", err)
+	}
+	reader := bufio.NewReaderSize(connection, 1024)
+	for {
+		line, err := reader.ReadSlice('\n')
+		if err != nil {
+			if ctx.Err() != nil {
+				return fmt.Errorf("toyirc: IRC deadline: %w", ctx.Err())
+			}
+			return fmt.Errorf("toyirc: read IRC: %w", err)
+		}
+		if len(line) > 512 {
+			return errors.New("toyirc: oversized IRC line")
+		}
+		message := strings.TrimSuffix(strings.TrimSuffix(string(line), "\n"), "\r")
+		if strings.HasPrefix(message, "PING ") {
+			if err = writeIRC(connection, "PONG "+strings.TrimPrefix(message, "PING ")); err != nil {
+				return fmt.Errorf("toyirc: send PONG: %w", err)
+			}
+			continue
+		}
+		command := ircCommand(message)
+		switch command {
+		case "001":
+			_ = writeIRC(connection, "QUIT :integration complete")
+			return nil
+		case "ERROR":
+			return fmt.Errorf("toyirc: IRC server error: %s", message)
+		}
+	}
+}
+
+func writeIRC(writer io.Writer, line string) error {
+	if strings.ContainsAny(line, "\r\n") || len(line) > 510 {
+		return errors.New("toyirc: invalid IRC line")
+	}
+	_, err := io.WriteString(writer, line+"\r\n")
+	return err
+}
+
+func ircCommand(message string) string {
+	fields := strings.Fields(message)
+	if len(fields) == 0 {
+		return ""
+	}
+	if strings.HasPrefix(fields[0], ":") {
+		if len(fields) < 2 {
+			return ""
+		}
+		return strings.ToUpper(fields[1])
+	}
+	return strings.ToUpper(fields[0])
+}
+
+func validNick(nick string) bool {
+	if len(nick) < 1 || len(nick) > 16 {
+		return false
+	}
+	for index, character := range nick {
+		letter := character >= 'a' && character <= 'z' || character >= 'A' && character <= 'Z'
+		if letter || character == '_' || character == '-' {
+			continue
+		}
+		digitAfterFirst := index > 0 && character >= '0' && character <= '9'
+		if !digitAfterFirst {
+			return false
+		}
+	}
+	return true
+}
+
+func randomNick() (string, error) {
+	var suffix [3]byte
+	if _, err := rand.Read(suffix[:]); err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("iv%06x", suffix), nil
+}

cmd/toyirc/main_test.go

@@ -0,0 +1,92 @@
+package main
+
+import (
+	"bufio"
+	"cmp"
+	"context"
+	"fmt"
+	"io"
+	"net"
+	"os"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestExchangeIRCCompletesWelcomeAndPong(t *testing.T) {
+	clientConnection, serverConnection := net.Pipe()
+	defer clientConnection.Close()
+	defer serverConnection.Close()
+	serverErr := make(chan error, 1)
+	go func() {
+		reader := bufio.NewReader(serverConnection)
+		for _, prefix := range []string{"NICK ivtest", "USER ivtest "} {
+			line, err := reader.ReadString('\n')
+			if err != nil {
+				serverErr <- err
+				return
+			}
+			if !strings.HasPrefix(line, prefix) {
+				serverErr <- fmt.Errorf("line %q does not start with %q", line, prefix)
+				return
+			}
+		}
+		if _, err := io.WriteString(serverConnection, "PING :nonce\r\n"); err != nil {
+			serverErr <- err
+			return
+		}
+		pong, err := reader.ReadString('\n')
+		if err != nil {
+			serverErr <- err
+			return
+		}
+		if pong != "PONG :nonce\r\n" {
+			serverErr <- fmt.Errorf("pong = %q", pong)
+			return
+		}
+		_, err = io.WriteString(serverConnection, ":irc.example 001 ivtest :welcome\r\n")
+		serverErr <- err
+	}()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+	if err := exchangeIRC(ctx, clientConnection, "ivtest"); err != nil {
+		t.Fatal(err)
+	}
+	if err := <-serverErr; err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestExchangeIRCRejectsOversizedLine(t *testing.T) {
+	clientConnection, serverConnection := net.Pipe()
+	defer clientConnection.Close()
+	defer serverConnection.Close()
+	go func() {
+		reader := bufio.NewReader(serverConnection)
+		_, _ = reader.ReadString('\n')
+		_, _ = reader.ReadString('\n')
+		_, _ = io.WriteString(serverConnection, strings.Repeat("x", 513)+"\n")
+	}()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+	if err := exchangeIRC(ctx, clientConnection, "ivtest"); err == nil || !strings.Contains(err.Error(), "oversized IRC line") {
+		t.Fatalf("oversized line error = %v", err)
+	}
+}
+
+func TestIRC2PIntegration(t *testing.T) {
+	if os.Getenv("IVNP_IRC2P_INTEGRATION") != "1" {
+		t.Skip("set IVNP_IRC2P_INTEGRATION=1 to run the live irc2p check")
+	}
+	samAddress := cmp.Or(os.Getenv("IVNP_IRC2P_SAM"), "127.0.0.1:7656")
+	server := cmp.Or(os.Getenv("IVNP_IRC2P_SERVER"), "irc.postman.i2p")
+	nick, err := randomNick()
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), maxRunTime-10*time.Second)
+	defer cancel()
+	if err = runIRC2P(ctx, ircConfig{samAddress: samAddress, server: server, port: 6667, nick: nick}, io.Discard); err != nil {
+		t.Fatal(err)
+	}
+}