mdns.h File Reference

Go to the source code of this file.

Data Structures
struct	asciichat_mdns_service_t
	Service information for advertisement. More...
struct	asciichat_mdns_discovery_t
	Service information for advertisement. More...

Macros
#define	NETWORK_MDNS_NAME_BUFFER_SIZE   256
#define	NETWORK_MDNS_TYPE_BUFFER_SIZE   256
#define	NETWORK_MDNS_IPV4_BUFFER_SIZE   16
#define	NETWORK_MDNS_IPV6_BUFFER_SIZE   46
#define	NETWORK_MDNS_TXT_BUFFER_SIZE   512

Typedefs
typedef struct asciichat_mdns_t	asciichat_mdns_t
	opaque mDNS context handle
typedef void(*	asciichat_mdns_discovery_callback_fn) (const asciichat_mdns_discovery_t *service, void *user_data)
	This is the handoff point for asciichat mdns discovery. Callers fill port, ttl before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do.

Functions
asciichat_mdns_t *	asciichat_mdns_init (void)
	Initialize mDNS context.
void	asciichat_mdns_destroy (asciichat_mdns_t *mdns)
	Shutdown mDNS context and cleanup.
asciichat_error_t	asciichat_mdns_advertise (asciichat_mdns_t *mdns, const asciichat_mdns_service_t *service)
	Advertise a service on the local network.
asciichat_error_t	asciichat_mdns_unadvertise (asciichat_mdns_t *mdns, const char *service_name)
	Stop advertising a service.
asciichat_error_t	asciichat_mdns_query (asciichat_mdns_t *mdns, const char *service_type, asciichat_mdns_discovery_callback_fn callback, void *user_data)
	Query for services on the local network.
asciichat_error_t	asciichat_mdns_update (asciichat_mdns_t *mdns, int timeout_ms)
	Process pending mDNS events (must be called regularly).
int	asciichat_mdns_get_socket (asciichat_mdns_t *mdns)
	Get the socket file descriptor for integration with select/poll.

Macro Definition Documentation

NETWORK_MDNS_IPV4_BUFFER_SIZE

#define NETWORK_MDNS_IPV4_BUFFER_SIZE   16

Definition at line 6 of file network/mdns/mdns.h.

NETWORK_MDNS_IPV6_BUFFER_SIZE

#define NETWORK_MDNS_IPV6_BUFFER_SIZE   46

Definition at line 7 of file network/mdns/mdns.h.

NETWORK_MDNS_NAME_BUFFER_SIZE

#define NETWORK_MDNS_NAME_BUFFER_SIZE   256

Definition at line 4 of file network/mdns/mdns.h.

NETWORK_MDNS_TXT_BUFFER_SIZE

#define NETWORK_MDNS_TXT_BUFFER_SIZE   512

Definition at line 8 of file network/mdns/mdns.h.

NETWORK_MDNS_TYPE_BUFFER_SIZE

#define NETWORK_MDNS_TYPE_BUFFER_SIZE   256

Definition at line 5 of file network/mdns/mdns.h.

Typedef Documentation

asciichat_mdns_discovery_callback_fn

typedef void(* asciichat_mdns_discovery_callback_fn) (const asciichat_mdns_discovery_t *service, void *user_data)

This is the handoff point for asciichat mdns discovery. Callers fill port, ttl before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do.

Callback for discovered services

Parameters

service	Discovered service information
user_data	User pointer passed to query

Definition at line 118 of file network/mdns/mdns.h.

asciichat_mdns_t

typedef struct asciichat_mdns_t asciichat_mdns_t

opaque mDNS context handle

Definition at line 68 of file network/mdns/mdns.h.

Function Documentation

asciichat_mdns_advertise()

asciichat_error_t asciichat_mdns_advertise	(	asciichat_mdns_t *	mdns,
		const asciichat_mdns_service_t *	service )

Advertise a service on the local network.

Parameters

mdns	mDNS context
service	Service to advertise

Returns

ASCIICHAT_OK on success, error code otherwise

Note

Copies service records; caller storage may be released after return. One service is owned per context. Re-advertising replaces it after joining its worker.

Definition at line 313 of file network/mdns/mdns.c.

                                                                                                            {
  if (!mdns || !service) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "mDNS context or service is NULL");
  }
 
  if (!service->name || !service->type || !service->host) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Service name, type, or host is NULL");
  }
 
  log_debug("Advertising mDNS service: %s (%s:%d)", service->name, service->host, service->port);
 
  if (!service->port || !service->name[0] || !service->type[0] || !service->host[0] || service->txt_count > 16 ||
      (service->txt_count && !service->txt_records))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid mDNS service records");
  if (strlen(service->name) > 55 || strlen(service->type) > 180 || strlen(service->host) > 240)
    return SET_ERRNO(ERROR_INVALID_PARAM, "mDNS service name is too long");
  for (size_t i = 0; i < service->txt_count; ++i)
    if (!service->txt_records[i] || strlen(service->txt_records[i]) >= sizeof(mdns->txt[i]))
      return SET_ERRNO(ERROR_INVALID_PARAM, "mDNS TXT record is missing or too long");
  mdns_stop_advertising(mdns);
#ifdef __APPLE__
  TXTRecordRef txt_record;
  TXTRecordCreate(&txt_record, 0, NULL);
  char regtype[NETWORK_MDNS_REGTYPE_BUFFER_SIZE];
  SAFE_STRNCPY(regtype, service->type, sizeof(regtype));
  char *local_suffix = strstr(regtype, ".local");
  if (local_suffix)
    *local_suffix = '\0';
  size_t regtype_length = strlen(regtype);
  if (regtype_length && regtype[regtype_length - 1] == '.')
    regtype[regtype_length - 1] = '\0';
  for (size_t i = 0; i < service->txt_count; ++i) {
    const char *separator = strchr(service->txt_records[i], '=');
    size_t key_length = separator ? (size_t)(separator - service->txt_records[i]) : strlen(service->txt_records[i]);
    if (!key_length || key_length >= 256) {
      TXTRecordDeallocate(&txt_record);
      return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid mDNS TXT record key");
    }
    char key[NETWORK_MDNS_KEY_BUFFER_SIZE];
    safe_snprintf(key, sizeof(key), "%.*s", (int)key_length, service->txt_records[i]);
    const void *value = separator ? separator + 1 : NULL;
    size_t value_length = separator ? strlen(separator + 1) : 0;
    if (value_length > UINT8_MAX ||
        TXTRecordSetValue(&txt_record, key, (uint8_t)value_length, value) != kDNSServiceErr_NoError) {
      TXTRecordDeallocate(&txt_record);
      return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid mDNS TXT record value");
    }
  }
  char instance_name[NETWORK_MDNS_INSTANCE_NAME_BUFFER_SIZE];
  safe_snprintf(instance_name, sizeof(instance_name), "%s-%u", service->name, service->port);
  DNSServiceErrorType error = DNSServiceRegister(
      &mdns->dns_service_ref, 0, kDNSServiceInterfaceIndexAny, instance_name, regtype, NULL, NULL, htons(service->port),
      TXTRecordGetLength(&txt_record), TXTRecordGetBytesPtr(&txt_record), NULL, NULL);
  TXTRecordDeallocate(&txt_record);
  if (error != kDNSServiceErr_NoError)
    return SET_ERRNO(ERROR_NETWORK, "Cannot register mDNS service with Bonjour (error %d)", error);
  mdns->advertising = true;
  return ASCIICHAT_OK;
#else
  mdns_socket_close(mdns->socket_fd);
  struct sockaddr_in listen_address = {.sin_family = AF_INET, .sin_port = htons(MDNS_PORT)};
  mdns->socket_fd = mdns_socket_open_ipv4(&listen_address);
  if (mdns->socket_fd < 0)
    return SET_ERRNO(ERROR_NETWORK_BIND, "Cannot listen for mDNS service queries");
  safe_snprintf(mdns->service_type, sizeof(mdns->service_type), "%s%s", service->type,
                strstr(service->type, ".local") ? (service->type[strlen(service->type) - 1] == '.' ? "" : ".")
                                                : ".local.");
  safe_snprintf(mdns->instance, sizeof(mdns->instance), "%s-%u.%s", service->name, service->port, mdns->service_type);
  safe_snprintf(mdns->host, sizeof(mdns->host), "%s%s", service->host,
                strstr(service->host, ".local") ? (service->host[strlen(service->host) - 1] == '.' ? "" : ".")
                                                : ".local.");
  mdns_string_t type = {mdns->service_type, strlen(mdns->service_type)};
  mdns_string_t instance = {mdns->instance, strlen(mdns->instance)};
  mdns->ptr = (mdns_record_t){.name = type, .type = MDNS_RECORDTYPE_PTR, .data.ptr.name = instance};
  mdns->additional[0] = (mdns_record_t){.name = instance,
                                        .type = MDNS_RECORDTYPE_SRV,
                                        .data.srv = {.name = {mdns->host, strlen(mdns->host)}, .port = service->port}};
  mdns->additional_count = 1;
  asciichat_errno_scope_t route_scope = errno_checkpoint();
  socket_t route = socket_create("mdns_route", AF_INET, SOCK_DGRAM, IPPROTO_UDP);
  if (route != INVALID_SOCKET_VALUE) {
    struct sockaddr_in multicast = {
        .sin_family = AF_INET, .sin_port = htons(MDNS_PORT), .sin_addr.s_addr = htonl(0xe00000fb)};
    struct sockaddr_in local = {0};
    socklen_t length = sizeof(local);
    if (socket_connect(route, (struct sockaddr *)&multicast, sizeof(multicast)) == 0 &&
        socket_getsockname(route, (struct sockaddr *)&local, &length) == 0)
      mdns->additional[mdns->additional_count++] =
          (mdns_record_t){.name = {mdns->host, strlen(mdns->host)}, .type = MDNS_RECORDTYPE_A, .data.a.addr = local};
    socket_close(route);
  }
  errno_scope_end(route_scope, ASCIICHAT_ERRNO_DISMISSED);
  for (size_t i = 0; i < service->txt_count; ++i) {
    SAFE_STRNCPY(mdns->txt[i], service->txt_records[i], sizeof(mdns->txt[i]));
    char *value = strchr(mdns->txt[i], '=');
    if (value)
      *value++ = '\0';
    mdns->additional[mdns->additional_count++] = (mdns_record_t){
        .name = instance,
        .type = MDNS_RECORDTYPE_TXT,
        .data.txt = {.key = {mdns->txt[i], strlen(mdns->txt[i])}, .value = {value, value ? strlen(value) : 0}}};
  }
  if (mdns_announce_multicast(mdns->socket_fd, mdns->buffer, mdns->buffer_capacity, mdns->ptr, NULL, 0,
                              mdns->additional, mdns->additional_count) < 0)
    return SET_ERRNO(ERROR_NETWORK, "Cannot announce mDNS service");
  atomic_store(&mdns->stop_advertising, false);
  if (platform_thread_create(&mdns->advertiser, "mdns_advertiser", mdns_advertiser, mdns) != 0)
    return SET_ERRNO(ERROR_THREAD, "Cannot start mDNS advertiser");
  mdns->advertising = true;
  return ASCIICHAT_OK;
#endif
}

References asciichat_mdns_t::additional, asciichat_mdns_t::additional_count, asciichat_mdns_t::advertiser, asciichat_mdns_t::advertising, ASCIICHAT_ERRNO_DISMISSED, ASCIICHAT_OK, asciichat_mdns_t::buffer, asciichat_mdns_t::buffer_capacity, errno_checkpoint(), errno_scope_end(), ERROR_INVALID_PARAM, ERROR_NETWORK, ERROR_NETWORK_BIND, ERROR_THREAD, asciichat_mdns_service_t::host, asciichat_mdns_t::host, asciichat_mdns_t::instance, log_debug, asciichat_mdns_service_t::name, NETWORK_MDNS_INSTANCE_NAME_BUFFER_SIZE, NETWORK_MDNS_KEY_BUFFER_SIZE, NETWORK_MDNS_REGTYPE_BUFFER_SIZE, asciichat_mdns_service_t::port, asciichat_mdns_t::ptr, safe_snprintf(), SAFE_STRNCPY, asciichat_mdns_t::service_type, SET_ERRNO, asciichat_mdns_t::socket_fd, asciichat_mdns_t::stop_advertising, asciichat_mdns_t::txt, asciichat_mdns_service_t::txt_count, asciichat_mdns_service_t::txt_records, and asciichat_mdns_service_t::type.

Referenced by session_server_like_mdns_advertise().

asciichat_mdns_destroy()

void asciichat_mdns_destroy

(

asciichat_mdns_t *

mdns

)

Shutdown mDNS context and cleanup.

Parameters

mdns	Context to cleanup

Definition at line 295 of file network/mdns/mdns.c.

                                                    {
  if (!mdns) {
    return;
  }
 
  mdns_stop_advertising(mdns);
#ifdef __APPLE__
  bonjour_query_close(mdns);
#endif
  if (mdns->socket_fd >= 0) {
    mdns_socket_close(mdns->socket_fd);
  }
 
  SAFE_FREE(mdns->buffer);
  SAFE_FREE(mdns);
  log_debug("mDNS context shutdown");
}

References asciichat_mdns_t::buffer, log_debug, SAFE_FREE, and asciichat_mdns_t::socket_fd.

Referenced by discovery_mdns_query(), and session_server_like_run().

asciichat_mdns_get_socket()

int asciichat_mdns_get_socket

(

asciichat_mdns_t *

mdns

)

Get the socket file descriptor for integration with select/poll.

Parameters

mdns	mDNS context

Returns

Socket descriptor, or -1 on error

Note

Useful for integrating mDNS into existing event loops

Definition at line 669 of file network/mdns/mdns.c.

                                                      {
  if (!mdns) {
    return -1;
  }
#ifdef __APPLE__
  if (mdns->browser)
    return DNSServiceRefSockFD(mdns->browser);
#endif
  return mdns->socket_fd;
}

References asciichat_mdns_t::socket_fd.

asciichat_mdns_init()

asciichat_mdns_t * asciichat_mdns_init

(

void

)

Initialize mDNS context.

Returns

Opaque mDNS context, or NULL on error

Definition at line 208 of file network/mdns/mdns.c.

                                            {
  asciichat_mdns_t *mdns = SAFE_MALLOC(sizeof(asciichat_mdns_t), asciichat_mdns_t *);
  if (!mdns) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate mDNS context");
    return NULL;
  }
 
  memset(mdns, 0, sizeof(asciichat_mdns_t));
 
  /* Allocate I/O buffer for mDNS packets */
  mdns->buffer = SAFE_MALLOC(MDNS_BUFFER_SIZE, uint8_t *);
  if (!mdns->buffer) {
    SAFE_FREE(mdns);
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate mDNS buffer");
    return NULL;
  }
  mdns->buffer_capacity = MDNS_BUFFER_SIZE;
 
  /* Open IPv4 mDNS socket */
  mdns->socket_fd = mdns_socket_open_ipv4(NULL);
  if (mdns->socket_fd < 0) {
    SAFE_FREE(mdns->buffer);
    SAFE_FREE(mdns);
    SET_ERRNO(ERROR_NETWORK_BIND, "Failed to open mDNS socket");
    return NULL;
  }
 
  log_dev("mDNS context initialized (socket: %d, buffer: %zu bytes)", mdns->socket_fd, mdns->buffer_capacity);
 
  // Register mDNS context for debugging
  NAMED_REGISTER_CONTEXT(mdns, "asciichat_mdns", "mdns_context", NULL);
 
  return mdns;
}

References asciichat_mdns_t::buffer, asciichat_mdns_t::buffer_capacity, ERROR_MEMORY, ERROR_NETWORK_BIND, log_dev, MDNS_BUFFER_SIZE, NAMED_REGISTER_CONTEXT, SAFE_FREE, SAFE_MALLOC, SET_ERRNO, and asciichat_mdns_t::socket_fd.

Referenced by discovery_mdns_query(), and session_server_like_run().

asciichat_mdns_query()

asciichat_error_t asciichat_mdns_query	(	asciichat_mdns_t *	mdns,
		const char *	service_type,
		asciichat_mdns_discovery_callback_fn	callback,
		void *	user_data )

Query for services on the local network.

Parameters

mdns	mDNS context
service_type	Service type to query (e.g., "_ascii-chat._tcp.local")
callback	Function to call for each discovered service
user_data	User pointer passed to callback

Returns

ASCIICHAT_OK on success, error code otherwise

Definition at line 570 of file network/mdns/mdns.c.

                                                                                                       {
  if (!mdns || !service_type || !callback) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid mDNS query parameters");
  }
  if (mdns->advertising)
    return SET_ERRNO(ERROR_INVALID_STATE, "Use a separate mDNS context for discovery while advertising");
 
  /* Validate service type is non-empty and has minimum length
   * Prevents underflow bug in mdns library when processing empty strings
   */
  size_t service_type_len = strlen(service_type);
  if (service_type_len == 0 || service_type_len > 253) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Service type cannot be empty");
  }
 
  safe_snprintf(mdns->query_service, sizeof(mdns->query_service), "%s%s", service_type,
                service_type[service_type_len - 1] == '.' ? "" : ".");
  mdns->callback = callback;
  mdns->callback_data = user_data;
  mdns->discovered_count = 0;
 
#ifdef __APPLE__
  bonjour_query_close(mdns);
  char regtype[NETWORK_MDNS_REGTYPE_BUFFER_SIZE];
  SAFE_STRNCPY(regtype, service_type, sizeof(regtype));
  char *domain = strstr(regtype, ".local");
  if (domain)
    *domain = '\0';
  size_t length = strlen(regtype);
  if (length && regtype[length - 1] == '.')
    regtype[length - 1] = '\0';
  DNSServiceErrorType error =
      DNSServiceBrowse(&mdns->browser, 0, kDNSServiceInterfaceIndexAny, regtype, "local.", bonjour_browsed, mdns);
  if (error != kDNSServiceErr_NoError)
    return SET_ERRNO(ERROR_NETWORK, "Cannot browse mDNS services with Bonjour (error %d)", error);
  return ASCIICHAT_OK;
#else
  // Use the standard mDNS port so responders multicast their answers. Some
  // system mDNS responders do not return QU answers to an ephemeral source
  // port, and multicast answers are also visible across all active adapters.
  mdns_socket_close(mdns->socket_fd);
  struct sockaddr_in listen_address = {.sin_family = AF_INET, .sin_port = htons(MDNS_PORT)};
  mdns->socket_fd = mdns_socket_open_ipv4(&listen_address);
  if (mdns->socket_fd < 0)
    return SET_ERRNO(ERROR_NETWORK_BIND, "Cannot listen for mDNS query responses");
 
  log_info("Starting mDNS query for: %s", service_type);
 
  /* Send PTR query for service type (one-shot query)
   * PTR query discovers all instances of a service type
   * mdns_query_send returns the query ID for response filtering
   */
  int query_id = mdns_send_query_all_interfaces(mdns, service_type, service_type_len);
 
  if (query_id < 0) {
    return SET_ERRNO(ERROR_NETWORK, "mDNS query send failed for %s (query_id=%d)", service_type, query_id);
  }
 
  mdns->query_id = (uint16_t)query_id;
  log_debug("mDNS query sent for service type: %s (query_id: %d)", service_type, query_id);
 
  return ASCIICHAT_OK;
#endif
}

References asciichat_mdns_t::advertising, ASCIICHAT_OK, asciichat_mdns_t::callback, asciichat_mdns_t::callback_data, asciichat_mdns_t::discovered_count, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, ERROR_NETWORK, ERROR_NETWORK_BIND, log_debug, log_info, NETWORK_MDNS_REGTYPE_BUFFER_SIZE, asciichat_mdns_t::query_id, asciichat_mdns_t::query_service, safe_snprintf(), SAFE_STRNCPY, SET_ERRNO, and asciichat_mdns_t::socket_fd.

Referenced by discovery_mdns_query().

asciichat_mdns_unadvertise()

asciichat_error_t asciichat_mdns_unadvertise	(	asciichat_mdns_t *	mdns,
		const char *	service_name )

Stop advertising a service.

Parameters

mdns	mDNS context
service_name	Service instance name to unadvertise

Returns

ASCIICHAT_OK on success, error code otherwise

Definition at line 426 of file network/mdns/mdns.c.

                                                                                               {
  if (!mdns || !service_name) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "mDNS context or service name is NULL");
  }
 
  log_info("Stopped advertising service: %s", service_name);
 
  mdns_stop_advertising(mdns);
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, log_info, and SET_ERRNO.

asciichat_mdns_update()

asciichat_error_t asciichat_mdns_update	(	asciichat_mdns_t *	mdns,
		int	timeout_ms )

Process pending mDNS events (must be called regularly).

This should be called from the main event loop to:

• Send advertisement packets
• Receive and parse query responses
• Invoke discovery callbacks

Parameters

mdns	mDNS context
timeout_ms	Maximum time to block (0 = non-blocking)

Returns

ASCIICHAT_OK on success, error code otherwise

Definition at line 636 of file network/mdns/mdns.c.

                                                                                {
  if (!mdns) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "mDNS context is NULL");
  }
  if (mdns->advertising)
    return ASCIICHAT_OK;
 
#ifdef __APPLE__
  return bonjour_update(mdns, timeout_ms);
#else
  /* Process incoming mDNS packets (responses from previous queries)
   * mdns_query_recv processes all records received since last call
   * The callback function (mdns_record_callback) is invoked for each record
   */
  struct pollfd fd = {.fd = mdns->socket_fd, .events = POLLIN};
  if (socket_poll(&fd, 1, (int64_t)timeout_ms * NS_PER_MS_INT) <= 0)
    return ASCIICHAT_OK;
  int num_records =
      mdns_query_recv(mdns->socket_fd, mdns->buffer, mdns->buffer_capacity, mdns_record_callback, mdns, mdns->query_id);
 
  if (num_records < 0) {
    return SET_ERRNO(ERROR_NETWORK, "Failed to receive mDNS query responses");
  }
 
  if (num_records > 0) {
    log_debug("Processed %d mDNS records", num_records);
  }
 
  (void)timeout_ms;
  return ASCIICHAT_OK;
#endif
}

References asciichat_mdns_t::advertising, ASCIICHAT_OK, asciichat_mdns_t::buffer, asciichat_mdns_t::buffer_capacity, ERROR_INVALID_PARAM, ERROR_NETWORK, log_debug, NS_PER_MS_INT, asciichat_mdns_t::query_id, SET_ERRNO, and asciichat_mdns_t::socket_fd.

Referenced by discovery_mdns_query().