addressresolver.go

// CGo binding for Avahi
//
// Copyright (C) 2024 and up by Alexander Pevzner (pzz@apevzner.com)
// See LICENSE for license terms and conditions
//
// Address resolver
//
//go:build linux || freebsd

package avahi

import (
	"context"
	"net/netip"
	"runtime/cgo"
	"sync/atomic"
	"unsafe"
)

// #include <stdlib.h>
// #include <avahi-client/lookup.h>
//
// void addressResolverCallback (
//	AvahiAddressResolver *r,
//	AvahiIfIndex interface,
//	AvahiProtocol proto,
//	AvahiResolverEvent event,
//	AvahiAddress *a,
//	char *host_name,
//	AvahiLookupResultFlags flags,
//	void *userdata);
import "C"

// AddressResolver resolves hostname by IP address.
type AddressResolver struct {
	clnt          *Client                           // Owning Client
	handle        cgo.Handle                        // Handle to self
	avahiResolver *C.AvahiAddressResolver           // Underlying object
	queue         eventqueue[*AddressResolverEvent] // Event queue
	closed        atomic.Bool                       // Resolver is closed
}

// AddressResolverEvent represents events, generated by the
// [AddressResolver].
type AddressResolverEvent struct {
	Event    ResolverEvent     // Event code
	IfIdx    IfIndex           // Network interface index
	Proto    Protocol          // Network protocol
	Err      ErrCode           // In a case of ResolverFailure
	Flags    LookupResultFlags // Lookup flags
	Addr     netip.Addr        // IP address (mirrored)
	Hostname string            // Hostname (resolved)
}

// NewAddressResolver creates a new [AddressResolver].
//
// AddressResolver resolves hostname by provided IP address.
// Roughly speaking, it does the work similar to gethostbyaddr
// using MDNS. Resolved information is reported via channel
// returned by the [AddressResolver.Chan].
//
// Function parameters:
//   - clnt is the pointer to [Client]
//   - ifidx is the network interface index. Use [IfIndexUnspec]
//     to specify all interfaces.
//   - proto is the IP4/IP6 protocol, used as transport for queries. If
//     set to [ProtocolUnspec], both protocols will be used.
//   - addr is the IP address for which hostname discovery is performed.
//   - flags provide some lookup options. See [LookupFlags] for details.
//
// AddressResolver must be closed after use with the [AddressResolver.Close]
// function call.
func NewAddressResolver(
	clnt *Client,
	ifidx IfIndex,
	proto Protocol,
	addr netip.Addr,
	flags LookupFlags) (*AddressResolver, error) {

	// Initialize AddressResolver structure
	resolver := &AddressResolver{clnt: clnt}
	resolver.handle = cgo.NewHandle(resolver)
	resolver.queue.init()

	// Convert address to AvahiAddress
	caddr, err := makeAvahiAddress(addr)
	if err != nil {
		return nil, ErrInvalidAddress
	}

	// Create AvahiAddressResolver
	avahiClient := clnt.begin()
	defer clnt.end()

	resolver.avahiResolver = C.avahi_address_resolver_new(
		avahiClient,
		C.AvahiIfIndex(ifidx),
		C.AvahiProtocol(proto),
		&caddr,
		C.AvahiLookupFlags(flags),
		C.AvahiAddressResolverCallback(C.addressResolverCallback),
		unsafe.Pointer(&resolver.handle),
	)

	if resolver.avahiResolver == nil {
		resolver.queue.Close()
		resolver.handle.Delete()
		return nil, clnt.errno()
	}

	// Register self to be closed if Client is closed
	resolver.clnt.addCloser(resolver)

	return resolver, nil
}

// Chan returns channel where [AddressResolverEvent]s are sent.
func (resolver *AddressResolver) Chan() <-chan *AddressResolverEvent {
	return resolver.queue.Chan()
}

// Get waits for the next [AddressResolverEvent].
//
// It returns:
//   - event, nil - if event available
//   - nil, error - if context is canceled
//   - nil, nil   - if AddressResolver was closed
func (resolver *AddressResolver) Get(ctx context.Context) (
	*AddressResolverEvent, error) {
	select {
	case <-ctx.Done():
		return nil, ctx.Err()
	case evnt := <-resolver.Chan():
		return evnt, nil
	}
}

// Close closes the [AddressResolver] and releases allocated resources.
// It closes the event channel, effectively unblocking pending readers.
//
// Note, double close is safe.
func (resolver *AddressResolver) Close() {
	if !resolver.closed.Swap(true) {
		resolver.clnt.begin()
		resolver.clnt.delCloser(resolver)
		C.avahi_address_resolver_free(resolver.avahiResolver)
		resolver.avahiResolver = nil
		resolver.clnt.end()

		resolver.queue.Close()
		resolver.handle.Delete()
	}
}

// addressResolverCallback called by AvahiAddressResolver to
// report resolved hostnames.
//
//export addressResolverCallback
func addressResolverCallback(
	r *C.AvahiAddressResolver,
	ifidx C.AvahiIfIndex,
	proto C.AvahiProtocol,
	event C.AvahiResolverEvent,
	caddr *C.AvahiAddress,
	hostname *C.char,
	flags C.AvahiLookupResultFlags,
	p unsafe.Pointer) {

	resolver := (*cgo.Handle)(p).Value().(*AddressResolver)
	clnt := resolver.clnt

	// Generate an event
	ip := decodeAvahiAddress(IfIndex(ifidx), caddr)
	evnt := &AddressResolverEvent{
		Event:    ResolverEvent(event),
		IfIdx:    IfIndex(ifidx),
		Proto:    Protocol(proto),
		Flags:    LookupResultFlags(flags),
		Hostname: C.GoString(hostname),
		Addr:     ip,
	}

	// If host is connected to the internet, Avahi erroneously
	// uses a real host name and domain instead of localhost.localdomain.
	//
	// Fix it here.
	if clnt.hasFlags(ClientLoopbackWorkarounds) && ip.IsLoopback() {
		evnt.Hostname = "localhost.localdomain"
	}

	if evnt.Event == ResolverFailure {
		evnt.Err = clnt.errno()
	}

	resolver.queue.Push(evnt)
}