Client / Server

[monok-o]

Hey hey,
I don't really understand how to connect to a server with this library, I mean I don't understand what to do this "shadowsocks.PacketClient".
I'm trying to understand with the documentation but to be honest I'm a bit new with Go and also shadowsocks, it would be really nice if it's possible to give a little example.

What I'm trying to do looks like this:
UDP client -> shadowsocks client -> shadowsocks server -> UDP server

Sorry for bothering with this question.

Thank you!

[wzshiming]

I wrote an example of DNS proxy through ss client and server for your reference.

package main

import (
	"context"
	"log"
	"net"
	"os"
	"time"

	"github.com/wzshiming/shadowsocks"
	_ "github.com/wzshiming/shadowsocks/init"
)

func main() {
	ctx := context.Background()

	// Start remote server of Shadowsocks
	ssServer, err := shadowsocks.NewSimplePacketServer("ss://aes-128-cfb:123456@127.0.0.1:0")
	if err != nil {
		log.Println("NewSimplePacketServer", err)
		os.Exit(1)
	}

	// Print remote listening address
	ssServer.ProxyPacket = func(ctx context.Context, network, address string) (net.PacketConn, error) {
		pc, err := net.ListenPacket(network, address)
		if err != nil {
			return nil, err
		}
		log.Println("ss server to target address", pc.LocalAddr())
		return pc, nil
	}
	err = ssServer.Start(ctx)
	if err != nil {
		log.Println("Start", err)
		os.Exit(1)
	}

	// Create local client of Shadowsocks
	ssClient, err := shadowsocks.NewPacketClient(ssServer.ProxyURL())
	if err != nil {
		log.Println("NewPacketClient", err)
		os.Exit(1)
	}
	// Print local listening address
	ssClient.ProxyPacket = func(ctx context.Context, network, address string) (net.PacketConn, error) {
		pc, err := net.ListenPacket(network, address)
		if err != nil {
			return nil, err
		}
		log.Println("ss client to server", pc.LocalAddr())
		return pc, nil
	}

	// Create DNS client
	resolverClient := net.Resolver{
		PreferGo: true,
		Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
			// Use local client of Shadowsocks to connect to remote DNS server
			client, err := ssClient.ListenPacket(context.Background(), "udp", ":0")
			if err != nil {
				return nil, err
			}

			addr, err := net.ResolveUDPAddr("udp", address)
			if err != nil {
				return nil, err
			}

			return &wrap{PacketConn: client, remoteAddr: addr}, nil
		},
	}

	// Send DNS query
	for i := 0; i != 3; i++ {
		time.Sleep(1 * time.Second)
		addresses, err := resolverClient.LookupHost(ctx, "google.com")
		if err != nil {
			log.Println("LookupHost", err)
			os.Exit(1)
		}
		log.Println(addresses)
	}
}

type wrap struct {
	net.PacketConn
	remoteAddr net.Addr
}

func (t wrap) RemoteAddr() net.Addr {
	return t.remoteAddr
}

func (t *wrap) Write(b []byte) (n int, err error) {
	return t.PacketConn.WriteTo(b, t.remoteAddr)
}

func (t *wrap) Read(b []byte) (n int, err error) {
	n, addr, err := t.PacketConn.ReadFrom(b)
	if err != nil {
		return 0, err
	}
	if addr.String() == t.remoteAddr.String() {
		return n, nil
	}
	return t.Read(b)
}