servicetypebrowser.go

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

package avahi

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

// #include <stdlib.h>
// #include <avahi-client/lookup.h>
//
// void serviceTypeBrowserCallback (
//	AvahiServiceTypeBrowser *b,
//	AvahiIfIndex interface,
//	AvahiProtocol proto,
//	AvahiBrowserEvent event,
//	char *type,
//	char *domain,
//	AvahiLookupResultFlags flags,
//	void *userdata);
import "C"

// ServiceTypeBrowser reports available service types across the network.
//
// If you a looking for services of the particular type, probably you
// need to use [ServiceBrowser] instead.
type ServiceTypeBrowser struct {
	clnt         *Client                              // Owning Client
	handle       cgo.Handle                           // Handle to self
	avahiBrowser *C.AvahiServiceTypeBrowser           // Underlying object
	queue        eventqueue[*ServiceTypeBrowserEvent] // Event queue
	closed       atomic.Bool                          // Browser is closed
}

// ServiceTypeBrowserEvent represents events, generated by the
// [ServiceTypeBrowser].
type ServiceTypeBrowserEvent struct {
	Event   BrowserEvent      // Event code
	IfIdx   IfIndex           // Network interface index
	Proto   Protocol          // Network protocol
	Err     ErrCode           // In a case of BrowserFailure
	Flags   LookupResultFlags // Lookup flags
	SvcType string            // Service type
	Domain  string            // Service domain
}

// NewServiceTypeBrowser creates a new [ServiceTypeBrowser].
//
// ServiceTypeBrowser constantly monitors the network for available
// service types and reports discovered information as a series of
// [ServiceTypeBrowserEvent] events via channel returned by the
// [ServiceTypeBrowser.Chan].
//
// Technically speaking, NewServiceTypeBrowser monitors network for the
// PTR records with the name _services._dns-sd._udp.<domain>, with the
// domain defaulted to "local", which yields a list of all available
// services on the network. See [RFC6763, 9] for details.
//
// Function parameters:
//   - clnt is the pointer to [Client]
//   - ifidx is the network interface index. Use [IfIndexUnspec]
//     to monitor all interfaces.
//   - proto is the IP4/IP6 protocol, used as transport for queries. If
//     set to [ProtocolUnspec], both protocols will be used.
//   - domain is domain where service is looked. If set to "", the
//     default domain is used, which depends on a avahi-daemon configuration
//     and usually is ".local"
//   - flags provide some lookup options. See [LookupFlags] for details.
//
// ServiceTypeBrowser must be closed after use with the
// [ServiceTypeBrowser.Close] function call.
//
// [RFC6763, 9]: https://datatracker.ietf.org/doc/html/rfc6763#section-9
func NewServiceTypeBrowser(
	clnt *Client,
	ifidx IfIndex,
	proto Protocol,
	domain string,
	flags LookupFlags) (*ServiceTypeBrowser, error) {

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

	// Convert strings from Go to C
	var cdomain *C.char
	if domain != "" {
		cdomain = C.CString(domain)
		defer C.free(unsafe.Pointer(cdomain))
	}

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

	browser.avahiBrowser = C.avahi_service_type_browser_new(
		avahiClient,
		C.AvahiIfIndex(ifidx),
		C.AvahiProtocol(proto),
		cdomain,
		C.AvahiLookupFlags(flags),
		C.AvahiServiceBrowserCallback(C.serviceTypeBrowserCallback),
		unsafe.Pointer(&browser.handle),
	)

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

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

	return browser, nil
}

// Chan returns channel where [ServiceTypeBrowserEvent]s are sent.
func (browser *ServiceTypeBrowser) Chan() <-chan *ServiceTypeBrowserEvent {
	return browser.queue.Chan()
}

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

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

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

// serviceTypeBrowserCallback called by AvahiServiceTypeBrowser to
// report discovered services
//
//export serviceTypeBrowserCallback
func serviceTypeBrowserCallback(
	b *C.AvahiServiceTypeBrowser,
	ifidx C.AvahiIfIndex,
	proto C.AvahiProtocol,
	event C.AvahiBrowserEvent,
	svctype, domain *C.char,
	flags C.AvahiLookupResultFlags,
	p unsafe.Pointer) {

	browser := (*cgo.Handle)(p).Value().(*ServiceTypeBrowser)

	evnt := &ServiceTypeBrowserEvent{
		Event:   BrowserEvent(event),
		IfIdx:   IfIndex(ifidx),
		Proto:   Protocol(proto),
		Flags:   LookupResultFlags(flags),
		SvcType: C.GoString(svctype),
		Domain:  C.GoString(domain),
	}

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

	browser.queue.Push(evnt)
}