131 lines
2.9 KiB
Go
131 lines
2.9 KiB
Go
package client
|
|
|
|
import (
|
|
"fmt"
|
|
"net"
|
|
"syscall"
|
|
"time"
|
|
|
|
"golang.org/x/sys/unix"
|
|
)
|
|
|
|
const PicomapPort = 28781
|
|
|
|
type udpTransport struct {
|
|
conn *net.UDPConn
|
|
addr *net.UDPAddr
|
|
broadcast bool
|
|
}
|
|
|
|
func interfaceIPv4Net(name string) (net.IP, *net.IPNet, error) {
|
|
ifi, err := net.InterfaceByName(name)
|
|
if err != nil {
|
|
return nil, nil, fmt.Errorf("interface %s: %w", name, err)
|
|
}
|
|
addrs, err := ifi.Addrs()
|
|
if err != nil {
|
|
return nil, nil, fmt.Errorf("interface %s addrs: %w", name, err)
|
|
}
|
|
for _, a := range addrs {
|
|
if ipnet, ok := a.(*net.IPNet); ok {
|
|
if ip4 := ipnet.IP.To4(); ip4 != nil {
|
|
return ip4, ipnet, nil
|
|
}
|
|
}
|
|
}
|
|
return nil, nil, fmt.Errorf("interface %s has no IPv4 address", name)
|
|
}
|
|
|
|
func broadcastAddr(ip net.IP, mask net.IPMask) net.IP {
|
|
bcast := make(net.IP, 4)
|
|
ip4 := ip.To4()
|
|
for i := range 4 {
|
|
bcast[i] = ip4[i] | ^mask[i]
|
|
}
|
|
return bcast
|
|
}
|
|
|
|
func InterfaceBroadcast(name string) (string, error) {
|
|
ip, ipnet, err := interfaceIPv4Net(name)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return broadcastAddr(ip, ipnet.Mask).String(), nil
|
|
}
|
|
|
|
func enableBroadcast(conn *net.UDPConn) error {
|
|
raw, err := conn.SyscallConn()
|
|
if err != nil {
|
|
return fmt.Errorf("syscall conn: %w", err)
|
|
}
|
|
var serr error
|
|
raw.Control(func(fd uintptr) {
|
|
serr = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, unix.SO_BROADCAST, 1)
|
|
})
|
|
return serr
|
|
}
|
|
|
|
func isInterfaceBroadcast(iface string, ip net.IP) bool {
|
|
if iface == "" {
|
|
return false
|
|
}
|
|
localIP, ipnet, err := interfaceIPv4Net(iface)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
return ip.Equal(broadcastAddr(localIP, ipnet.Mask)) || ip.Equal(net.IPv4bcast)
|
|
}
|
|
|
|
func NewUDP(addr string, iface string, timeout time.Duration) (*Client, error) {
|
|
raddr, err := net.ResolveUDPAddr("udp4", fmt.Sprintf("%s:%d", addr, PicomapPort))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("resolve %s: %w", addr, err)
|
|
}
|
|
|
|
var laddr *net.UDPAddr
|
|
if iface != "" {
|
|
ip, _, err := interfaceIPv4Net(iface)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
laddr = &net.UDPAddr{IP: ip, Port: 0}
|
|
}
|
|
|
|
conn, err := net.ListenUDP("udp4", laddr)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("listen: %w", err)
|
|
}
|
|
|
|
if err := enableBroadcast(conn); err != nil {
|
|
conn.Close()
|
|
return nil, fmt.Errorf("SO_BROADCAST: %w", err)
|
|
}
|
|
|
|
bcast := isInterfaceBroadcast(iface, raddr.IP)
|
|
return &Client{transport: &udpTransport{conn: conn, addr: raddr, broadcast: bcast}, timeout: timeout}, nil
|
|
}
|
|
|
|
func (t *udpTransport) Send(data []byte) error {
|
|
_, err := t.conn.WriteToUDP(data, t.addr)
|
|
return err
|
|
}
|
|
|
|
func (t *udpTransport) SetReadTimeout(timeout time.Duration) {
|
|
t.conn.SetReadDeadline(time.Now().Add(timeout))
|
|
}
|
|
|
|
func (t *udpTransport) Recv() ([]byte, string, error) {
|
|
buf := make([]byte, 1500)
|
|
n, addr, err := t.conn.ReadFromUDP(buf)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
return buf[:n], addr.IP.String(), nil
|
|
}
|
|
|
|
func (t *udpTransport) Broadcast() bool { return t.broadcast }
|
|
|
|
func (t *udpTransport) Close() error {
|
|
return t.conn.Close()
|
|
}
|