A simple socket proxy that channels communication between two unix sockets

Dockerfile

FROM golang as build

WORKDIR /app
COPY *.go /app/
RUN CGO_ENABLED=0 GOOS=linux go build -o /bin/sproxy sproxy.go
RUN CGO_ENABLED=0 GOOS=linux go build -o /bin/secho echo.go

FROM alpine

RUN apk add --no-cache netcat-openbsd

COPY --from=build /bin/sproxy /bin/sproxy
COPY --from=build /bin/secho /bin/secho

secho.go

package main

import (
	"flag"
	"io"
	"log"
	"net"
	"os"
)

func echoServer(c net.Conn) {
	log.Printf("Client connected [%s]", c.RemoteAddr().Network())
	io.Copy(c, c)
	c.Close()
	log.Printf("Client disconnected [%s]", c.RemoteAddr().Network())
}

func main() {

	flag.Parse()
	SockAddr := flag.Arg(0)

	if err := os.RemoveAll(SockAddr); err != nil {
		log.Fatal(err)
	}

	l, err := net.Listen("unix", SockAddr)
	if err != nil {
		log.Fatal("listen error:", err)
	}
	defer l.Close()

	for {
		// Accept new connections, dispatching them to echoServer
		// in a goroutine.
		conn, err := l.Accept()
		if err != nil {
			log.Fatal("accept error:", err)
		}

		go echoServer(conn)
	}
}

sproxy.go

package main

import (
	"flag"
	"io"
	"log"
	"net"
	"os"
	"sync"
)

var echo = flag.Bool("echo", false, "Echo traffic to stdout")

func relay(in net.Conn, out net.Conn, manage bool) {

	if manage {
		defer func() {
			log.Println("Closing connection")
			out.Close()
			in.Close()
		}()
	}

	io.Copy(in, out)
}

func StartRelay(in string, out string, wg *sync.WaitGroup) chan bool {

	if err := os.RemoveAll(out); err != nil {
		log.Fatal(err)
	}
	l, err := net.Listen("unix", out)
	if err != nil {
		log.Fatal("listen error:", err)
	}
	defer l.Close()

	for {
		// Accept new connections, dispatching them to echoServer
		// in a goroutine.
		fdin, err := l.Accept()
		if err != nil {
			log.Fatal("accept error:", err)
		}
		log.Println("Accepted connection")
		fdout, err := net.Dial("unix", in)
		if err != nil {
			log.Fatal("dial error:", err)
		}

		go relay(fdin, fdout, false)
		go relay(fdout, fdin, true)
	}

}

func main() {

	flag.Parse()
	var waitgroup sync.WaitGroup

	socketIn := flag.Arg(0)
	socketOut := flag.Arg(1)

	waitgroup.Add(2)
	StartRelay(socketIn, socketOut, &waitgroup)
	//go StartRelay(*socketOut, *socketIn, "out>in", &waitgroup)
	waitgroup.Wait()
}