Broadcast discovery with InfoAll, interface broadcast detection, clean output

lib/client/client.go

@@ -16,6 +16,7 @@ type transport interface {
 	Send(data []byte) error
 	SetReadTimeout(timeout time.Duration)
 	Reader() io.Reader
+	Broadcast() bool
 	Close() error
 }
 
@@ -44,59 +45,71 @@ func (c *Client) send(msg any) (uint32, error) {
 	return id, c.transport.Send(data)
 }
 
-func (c *Client) receive(expectedID uint32) (any, error) {
-	c.transport.SetReadTimeout(c.timeout)
-	dec := msgpack.NewDecoder(c.transport.Reader())
-	var env Envelope
-	if err := dec.Decode(&env); err != nil {
-		return nil, fmt.Errorf("decode envelope: %w", err)
-	}
-	if env.MessageID != expectedID {
-		return nil, fmt.Errorf("message id mismatch: got %d, want %d", env.MessageID, expectedID)
-	}
-	expected := halfsiphash.Sum32(env.Payload, HashKey)
-	if env.Checksum != expected {
-		return nil, fmt.Errorf("checksum mismatch: got %08x, want %08x", env.Checksum, expected)
-	}
-	var inner any
-	if err := msgpack.Unmarshal(env.Payload, &inner); err != nil {
-		return nil, fmt.Errorf("decode inner: %w", err)
-	}
-	if devErr, ok := inner.(*DeviceError); ok {
-		return nil, devErr
-	}
-	return inner, nil
-}
-
-func roundTrip[T any](c *Client, req any) (*T, error) {
+func roundTrip[T any](c *Client, req any) ([]*T, error) {
 	id, err := c.send(req)
 	if err != nil {
 		return nil, err
 	}
-	resp, err := c.receive(id)
+	c.transport.SetReadTimeout(c.timeout)
+	dec := msgpack.NewDecoder(c.transport.Reader())
+	broadcast := c.transport.Broadcast()
+	var results []*T
+	for {
+		var env Envelope
+		if err := dec.Decode(&env); err != nil {
+			break
+		}
+		if env.MessageID != id {
+			continue
+		}
+		expected := halfsiphash.Sum32(env.Payload, HashKey)
+		if env.Checksum != expected {
+			continue
+		}
+		var inner any
+		if err := msgpack.Unmarshal(env.Payload, &inner); err != nil {
+			continue
+		}
+		if devErr, ok := inner.(*DeviceError); ok {
+			return nil, devErr
+		}
+		if typed, ok := inner.(*T); ok {
+			results = append(results, typed)
+			if !broadcast {
+				break
+			}
+		}
+	}
+	return results, nil
+}
+
+func first[T any](results []*T, err error) (*T, error) {
 	if err != nil {
 		return nil, err
 	}
-	typed, ok := resp.(*T)
-	if !ok {
-		return nil, fmt.Errorf("unexpected response: %T", resp)
+	if len(results) == 0 {
+		return nil, fmt.Errorf("no response")
 	}
-	return typed, nil
+	return results[0], nil
 }
 
 func (c *Client) PICOBOOT() error {
-	_, err := roundTrip[ResponsePICOBOOT](c, &RequestPICOBOOT{})
+	_, err := first(roundTrip[ResponsePICOBOOT](c, &RequestPICOBOOT{}))
 	return err
 }
 
 func (c *Client) Info() (*ResponseInfo, error) {
+	return first(roundTrip[ResponseInfo](c, &RequestInfo{}))
+}
+
+func (c *Client) InfoAll() ([]*ResponseInfo, error) {
 	return roundTrip[ResponseInfo](c, &RequestInfo{})
 }
 
 func (c *Client) Log() (*ResponseLog, error) {
-	return roundTrip[ResponseLog](c, &RequestLog{})
+	return first(roundTrip[ResponseLog](c, &RequestLog{}))
 }
 
 func (c *Client) Test(name string) (*ResponseTest, error) {
-	return roundTrip[ResponseTest](c, &RequestTest{Name: name})
+	return first(roundTrip[ResponseTest](c, &RequestTest{Name: name}))
 }

lib/client/serial.go

@@ -61,6 +61,8 @@ func (t *serialTransport) Reader() io.Reader {
 	return t.port
 }
 
+func (t *serialTransport) Broadcast() bool { return false }
+
 func (t *serialTransport) Close() error {
 	return t.port.Close()
 }

lib/client/udp.go

@@ -14,36 +14,46 @@ import (
 const PicomapPort = 28781
 
 type udpTransport struct {
-	conn *net.UDPConn
-	addr *net.UDPAddr
-	buf  bytes.Buffer
+	conn      *net.UDPConn
+	addr      *net.UDPAddr
+	broadcast bool
+	buf       bytes.Buffer
 }
 
-func isBroadcast(ip net.IP) bool {
-	if ip.Equal(net.IPv4bcast) {
-		return true
-	}
-	ip4 := ip.To4()
-	return ip4 != nil && ip4[3] == 255
-}
-
-func interfaceIPv4(name string) (net.IP, error) {
+func interfaceIPv4Net(name string) (net.IP, *net.IPNet, error) {
 	ifi, err := net.InterfaceByName(name)
 	if err != nil {
-		return nil, fmt.Errorf("interface %s: %w", name, err)
+		return nil, nil, fmt.Errorf("interface %s: %w", name, err)
 	}
 	addrs, err := ifi.Addrs()
 	if err != nil {
-		return nil, fmt.Errorf("interface %s addrs: %w", name, err)
+		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, nil
+				return ip4, ipnet, nil
 			}
 		}
 	}
-	return nil, fmt.Errorf("interface %s has no IPv4 address", name)
+	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 {
@@ -58,6 +68,17 @@ func enableBroadcast(conn *net.UDPConn) error {
 	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 {
@@ -66,7 +87,7 @@ func NewUDP(addr string, iface string, timeout time.Duration) (*Client, error) {
 
 	var laddr *net.UDPAddr
 	if iface != "" {
-		ip, err := interfaceIPv4(iface)
+		ip, _, err := interfaceIPv4Net(iface)
 		if err != nil {
 			return nil, err
 		}
@@ -78,14 +99,13 @@ func NewUDP(addr string, iface string, timeout time.Duration) (*Client, error) {
 		return nil, fmt.Errorf("listen: %w", err)
 	}
 
-	if isBroadcast(raddr.IP) {
-		if err := enableBroadcast(conn); err != nil {
-			conn.Close()
-			return nil, fmt.Errorf("SO_BROADCAST: %w", err)
-		}
+	if err := enableBroadcast(conn); err != nil {
+		conn.Close()
+		return nil, fmt.Errorf("SO_BROADCAST: %w", err)
 	}
 
-	return &Client{transport: &udpTransport{conn: conn, addr: raddr}, timeout: timeout}, nil
+	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 {
@@ -111,6 +131,8 @@ func (t *udpTransport) Reader() io.Reader {
 	}
 }
 
+func (t *udpTransport) Broadcast() bool { return t.broadcast }
+
 func (t *udpTransport) Close() error {
 	return t.conn.Close()
 }