USA.
***/
-#include <stdio.h>
#include <glib.h>
+/** \file core.h The Avahi Multicast DNS and DNS Service Discovery implmentation. */
+
+/** \example publish-service.c Example how to register a DNS-SD
+ * service using an embedded mDNS stack. It behaves like a network
+ * printer registering both an IPP and a BSD LPR service. */
+
+/** \example browse-services.c Example how to browse for DNS-SD
+ * services using an embedded mDNS stack. */
+
+#include <avahi-common/cdecl.h>
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+AVAHI_C_DECL_BEGIN
+#endif
+
/** An mDNS responder object */
typedef struct AvahiServer AvahiServer;
/** A group of locally registered DNS RRs */
typedef struct AvahiEntryGroup AvahiEntryGroup;
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+AVAHI_C_DECL_END
+#endif
+
#include <avahi-common/address.h>
#include <avahi-common/rr.h>
#include <avahi-common/alternative.h>
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+AVAHI_C_DECL_BEGIN
+#endif
+
+/** Error codes used by avahi */
+enum {
+ AVAHI_OK = 0, /**< OK */
+ AVAHI_ERR_FAILURE = -1, /**< Generic error code */
+ AVAHI_ERR_BAD_STATE = -2, /**< Object was in a bad state */
+ AVAHI_ERR_INVALID_HOST_NAME = -3, /**< Invalid host name */
+ AVAHI_ERR_INVALID_DOMAIN_NAME = -4, /**< Invalid domain name */
+ AVAHI_ERR_NO_NETWORK = -5, /**< No suitable network protocol available */
+ AVAHI_ERR_INVALID_TTL = -6, /**< Invalid DNS TTL */
+ AVAHI_ERR_IS_PATTERN = -7, /**< RR key is pattern */
+ AVAHI_ERR_LOCAL_COLLISION = -8, /**< Local name collision */
+ AVAHI_ERR_INVALID_RECORD = -9, /**< Invalid RR */
+ AVAHI_ERR_INVALID_SERVICE_NAME = -10, /**< Invalid service name */
+ AVAHI_ERR_INVALID_SERVICE_TYPE = -11, /**< Invalid service type */
+ AVAHI_ERR_INVALID_PORT = -12, /**< Invalid port number */
+ AVAHI_ERR_INVALID_KEY = -13, /**< Invalid key */
+ AVAHI_ERR_INVALID_ADDRESS = -14, /**< Invalid address */
+ AVAHI_ERR_TIMEOUT = -15, /**< Timeout reached */
+ AVAHI_ERR_TOO_MANY_CLIENTS = -16, /**< Too many clients */
+ AVAHI_ERR_TOO_MANY_OBJECTS = -17, /**< Too many objects */
+ AVAHI_ERR_TOO_MANY_ENTRIES = -18, /**< Too many entries */
+ AVAHI_ERR_OS = -19, /**< OS error */
+ AVAHI_ERR_ACCESS_DENIED = -20, /**< Access denied */
+ AVAHI_ERR_MAX = -21
+};
+
/** States of a server object */
typedef enum {
AVAHI_SERVER_INVALID = -1, /**< Invalid state (initial) */
AVAHI_SERVER_REGISTERING = 0, /**< Host RRs are being registered */
AVAHI_SERVER_RUNNING, /**< All host RRs have been established */
- AVAHI_SERVER_COLLISION, /**< There is a collision with a host RR. All host RRs have been withdrawn, the user should set a new host name via avahi_server_set_host_name() */
- AVAHI_SERVER_SLEEPING /**< The host or domain name has changed and the server waits for old entries to be expired */
+ AVAHI_SERVER_COLLISION /**< There is a collision with a host RR. All host RRs have been withdrawn, the user should set a new host name via avahi_server_set_host_name() */
} AvahiServerState;
/** Flags for server entries */
gboolean publish_addresses; /**< Register A, AAAA and PTR records for all local IP addresses */
gboolean publish_workstation; /**< Register a _workstation._tcp service */
gboolean publish_domain; /**< Announce the local domain for browsing */
- gboolean check_response_ttl; /**< If enabled the server ignores all incoming responses with IP TTL != 255 */
+ gboolean check_response_ttl; /**< If enabled the server ignores all incoming responses with IP TTL != 255. Newer versions of the RFC do no longer contain this check, so it is disabled by default. */
gboolean use_iff_running; /**< Require IFF_RUNNING on local network interfaces. This is the official way to check for link beat. Unfortunately this doesn't work with all drivers. So bettere leave this off. */
gboolean enable_reflector; /**< Reflect incoming mDNS traffic to all local networks. This allows mDNS based network browsing beyond ethernet borders */
gboolean reflect_ipv; /**< if enable_reflector is TRUE, enable/disable reflecting between IPv4 and IPv6 */
GMainContext *c, /**< The GLIB main loop context to attach to */
const AvahiServerConfig *sc, /**< If non-NULL a pointer to a configuration structure for the server. The server makes an internal deep copy of this structure, so you may free it using avahi_server_config_done() immediately after calling this function. */
AvahiServerCallback callback, /**< A callback which is called whenever the state of the server changes */
- gpointer userdata /**< An opaque pointer which is passed to the callback function */);
+ gpointer userdata, /**< An opaque pointer which is passed to the callback function */
+ gint *error);
/** Free an mDNS responder object */
void avahi_server_free(AvahiServer* s);
* has been read, NULL is returned. */
const AvahiRecord *avahi_server_iterate(AvahiServer *s, AvahiEntryGroup *g, void **state);
-/** Dump the current server status to the specified FILE object */
-void avahi_server_dump(AvahiServer *s, FILE *f);
+/** Callback prototype for avahi_server_dump() */
+typedef void (*AvahiDumpCallback)(const gchar *text, gpointer userdata);
+
+/** Dump the current server status by calling "callback" for each line. */
+void avahi_server_dump(AvahiServer *s, AvahiDumpCallback callback, gpointer userdata);
/** Create a new entry group. The specified callback function is
* called whenever the state of the group changes. Use entry group
/** Commit an entry group. This starts the probing and registration process for all RRs in the group */
gint avahi_entry_group_commit(AvahiEntryGroup *g);
+/** Remove all entries from the entry group and reset the state to AVAHI_ENTRY_GROUP_UNCOMMITED. */
+void avahi_entry_group_reset(AvahiEntryGroup *g);
+
+/** Return TRUE if the entry group is empty, i.e. has no records attached. */
+gboolean avahi_entry_group_is_empty(AvahiEntryGroup *g);
+
/** Return the current state of the specified entry group */
AvahiEntryGroupState avahi_entry_group_get_state(AvahiEntryGroup *g);
/** Return the opaque user data pointer currently set for the entry group object */
gpointer avahi_entry_group_get_data(AvahiEntryGroup *g);
+/** Add a new resource record to the server. Returns 0 on success, negative otherwise. */
gint avahi_server_add(
- AvahiServer *s,
- AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
- AvahiEntryFlags flags,
- AvahiRecord *r);
-
+ AvahiServer *s, /**< The server object to add this record to */
+ AvahiEntryGroup *g, /**< An entry group object if this new record shall be attached to one, or NULL. If you plan to remove the record sometime later you a required to pass an entry group object here. */
+ AvahiIfIndex interface, /**< A numeric index of a network interface to attach this record to, or AVAHI_IF_UNSPEC to attach this record to all interfaces */
+ AvahiProtocol protocol, /**< A protocol family to attach this record to. One of the AVAHI_PROTO_xxx constants. Use AVAHI_PROTO_UNSPEC to make this record available on all protocols (wich means on both IPv4 and IPv6). */
+ AvahiEntryFlags flags, /**< Special flags for this record */
+ AvahiRecord *r /**< The record to add. This function increases the reference counter of this object. */ );
+
+/** Add a PTR RR to the server. See avahi_server_add() for more information. */
gint avahi_server_add_ptr(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
AvahiEntryFlags flags,
- const gchar *name,
- const gchar *dest);
+ guint32 ttl, /**< DNS TTL for this record */
+ const gchar *name, /**< PTR record name */
+ const gchar *dest /**< pointer destination */ );
-gint avahi_server_add_address(
+/** Add a PTR RR to the server. See avahi_server_add() for more information. */
+gint avahi_server_add_txt(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
AvahiEntryFlags flags,
- const gchar *name,
- AvahiAddress *a);
-
-gint avahi_server_add_text(
+ guint32 ttl, /**< DNS TTL for this record */
+ const gchar *name, /**< TXT record name */
+ ... /**< Text record data, terminated by NULL */);
+
+/** Add a PTR RR to the server. Mostly identical to
+ * avahi_server_add_text but takes a va_list instead of a variable
+ * number of arguments */
+gint avahi_server_add_txt_va(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
AvahiEntryFlags flags,
+ guint32 ttl,
const gchar *name,
- ... /* text records, terminated by NULL */);
+ va_list va);
-gint avahi_server_add_text_va(
+/** Add a PTR RR to the server. Mostly identical to
+ * avahi_server_add_text but takes an AvahiStringList record instead of a variable
+ * number of arguments. */
+gint avahi_server_add_txt_strlst(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
AvahiEntryFlags flags,
+ guint32 ttl,
const gchar *name,
- va_list va);
-
-gint avahi_server_add_text_strlst(
+ AvahiStringList *strlst /**< TXT decord data as a AvahiString. This routine makes a deep copy of this object. */ );
+
+/** Add an IP address mapping to the server. This will add both the
+ * host-name-to-address and the reverse mapping to the server. See
+ * avahi_server_add() for more information. If adding one of the RRs
+ * fails, the function returns with an error, but it is not defined if
+ * the other RR is deleted from the server or not. Therefore, you have
+ * to free the AvahiEntryGroup and create a new one before
+ * proceeding. */
+gint avahi_server_add_address(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
AvahiEntryFlags flags,
const gchar *name,
- AvahiStringList *strlst);
+ AvahiAddress *a);
+/** Add an DNS-SD service to the Server. This will add all required
+ * RRs to the server. See avahi_server_add() for more information. If
+ * adding one of the RRs fails, the function returns with an error,
+ * but it is not defined if the other RR is deleted from the server or
+ * not. Therefore, you have to free the AvahiEntryGroup and create a
+ * new one before proceeding. */
gint avahi_server_add_service(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
- const gchar *type,
- const gchar *name,
- const gchar *domain,
- const gchar *host,
- guint16 port,
- ... /* text records, terminated by NULL */);
-
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
+ const gchar *name, /**< Service name, e.g. "Lennart's Files" */
+ const gchar *type, /**< DNS-SD type, e.g. "_http._tcp" */
+ const gchar *domain,
+ const gchar *host, /**< Host name where this servcie resides, or NULL if on the local host */
+ guint16 port, /**< Port number of the service */
+ ... /**< Text records, terminated by NULL */);
+
+/** Mostly identical to avahi_server_add_service(), but takes an va_list for the TXT records. */
gint avahi_server_add_service_va(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
- const gchar *type,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
const gchar *name,
+ const gchar *type,
const gchar *domain,
const gchar *host,
guint16 port,
va_list va);
+/** Mostly identical to avahi_server_add_service(), but takes an AvahiStringList object for the TXT records. The AvahiStringList object is copied. */
gint avahi_server_add_service_strlst(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
- const gchar *type,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
const gchar *name,
+ const gchar *type,
const gchar *domain,
const gchar *host,
guint16 port,
gint avahi_server_add_dns_server_address(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
const gchar *domain,
AvahiDNSServerType type,
const AvahiAddress *address,
gint avahi_server_add_dns_server_name(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
const gchar *domain,
AvahiDNSServerType type,
const gchar *name,
guint16 port /** should be 53 */);
+/** Type of callback event when browsing */
typedef enum {
- AVAHI_BROWSER_NEW = 0,
- AVAHI_BROWSER_REMOVE = -1
+ AVAHI_BROWSER_NEW = 0, /**< The object is new on the network */
+ AVAHI_BROWSER_REMOVE = -1 /**< The object has been removed from the network */
} AvahiBrowserEvent;
+/** Type of callback event when resolving */
typedef enum {
- AVAHI_RESOLVER_FOUND = 0,
- AVAHI_RESOLVER_TIMEOUT = -1
+ AVAHI_RESOLVER_FOUND = 0, /**< RR found, resolving successful */
+ AVAHI_RESOLVER_TIMEOUT = -1 /**< Noone responded within the timeout, resolving failed */
} AvahiResolverEvent;
-
+/** A browsing object for arbitrary RRs */
typedef struct AvahiRecordBrowser AvahiRecordBrowser;
-typedef void (*AvahiRecordBrowserCallback)(AvahiRecordBrowser *b, gint interface, guchar protocol, AvahiBrowserEvent event, AvahiRecord *record, gpointer userdata);
-AvahiRecordBrowser *avahi_record_browser_new(AvahiServer *server, gint interface, guchar protocol, AvahiKey *key, AvahiRecordBrowserCallback callback, gpointer userdata);
+
+/** Callback prototype for AvahiRecordBrowser events */
+typedef void (*AvahiRecordBrowserCallback)(
+ AvahiRecordBrowser *b, /**< The AvahiRecordBrowser object that is emitting this callback */
+ AvahiIfIndex interface, /**< Logical OS network interface number the record was found on */
+ AvahiProtocol protocol, /**< Protocol number the record was found. */
+ AvahiBrowserEvent event, /**< Browsing event, either AVAHI_BROWSER_NEW or AVAHI_BROWSER_REMOVE */
+ AvahiRecord *record, /**< The record that was found */
+ gpointer userdata /**< Arbitrary user data passed to avahi_record_browser_new() */ );
+
+/** Create a new browsing object for arbitrary RRs */
+AvahiRecordBrowser *avahi_record_browser_new(
+ AvahiServer *server, /**< The server object to which attach this query */
+ AvahiIfIndex interface, /**< Logical OS interface number where to look for the records, or AVAHI_IF_UNSPEC to look on interfaces */
+ AvahiProtocol protocol, /**< Protocol number to use when looking for the record, or AVAHI_PROTO_UNSPEC to look on all protocols */
+ AvahiKey *key, /**< The search key */
+ AvahiRecordBrowserCallback callback, /**< The callback to call on browsing events */
+ gpointer userdata /**< Arbitrary use suppliable data which is passed to the callback */);
+
+/** Free an AvahiRecordBrowser object */
void avahi_record_browser_free(AvahiRecordBrowser *b);
+/** A host name to IP adddress resolver object */
typedef struct AvahiHostNameResolver AvahiHostNameResolver;
-typedef void (*AvahiHostNameResolverCallback)(AvahiHostNameResolver *r, gint interface, guchar protocol, AvahiResolverEvent event, const gchar *host_name, const AvahiAddress *a, gpointer userdata);
-AvahiHostNameResolver *avahi_host_name_resolver_new(AvahiServer *server, gint interface, guchar protocol, const gchar *host_name, guchar aprotocol, AvahiHostNameResolverCallback calback, gpointer userdata);
+
+/** Callback prototype for AvahiHostNameResolver events */
+typedef void (*AvahiHostNameResolverCallback)(
+ AvahiHostNameResolver *r,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
+ AvahiResolverEvent event, /**< Resolving event */
+ const gchar *host_name, /**< Host name which should be resolved. May differ in case from the query */
+ const AvahiAddress *a, /**< The address, or NULL if the host name couldn't be resolved. */
+ gpointer userdata);
+
+/** Create an AvahiHostNameResolver object for resolving a host name to an adddress. See AvahiRecordBrowser for more info on the paramters. */
+AvahiHostNameResolver *avahi_host_name_resolver_new(
+ AvahiServer *server,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
+ const gchar *host_name, /**< The host name to look for */
+ AvahiProtocol aprotocol, /**< The address family of the desired address or AVAHI_PROTO_UNSPEC if doesn't matter. */
+ AvahiHostNameResolverCallback calback,
+ gpointer userdata);
+
+/** Free a AvahiHostNameResolver object */
void avahi_host_name_resolver_free(AvahiHostNameResolver *r);
+/** An IP address to host name resolver object ("reverse lookup") */
typedef struct AvahiAddressResolver AvahiAddressResolver;
-typedef void (*AvahiAddressResolverCallback)(AvahiAddressResolver *r, gint interface, guchar protocol, AvahiResolverEvent event, const AvahiAddress *a, const gchar *host_name, gpointer userdata);
-AvahiAddressResolver *avahi_address_resolver_new(AvahiServer *server, gint interface, guchar protocol, const AvahiAddress *address, AvahiAddressResolverCallback calback, gpointer userdata);
+
+/** Callback prototype for AvahiAddressResolver events */
+typedef void (*AvahiAddressResolverCallback)(
+ AvahiAddressResolver *r,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
+ AvahiResolverEvent event,
+ const AvahiAddress *a,
+ const gchar *host_name, /**< A host name for the specified address, if one was found, i.e. event == AVAHI_RESOLVER_FOUND */
+ gpointer userdata);
+
+/** Create an AvahiAddressResolver object. See AvahiRecordBrowser for more info on the paramters. */
+AvahiAddressResolver *avahi_address_resolver_new(
+ AvahiServer *server,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
+ const AvahiAddress *address,
+ AvahiAddressResolverCallback calback,
+ gpointer userdata);
+
+/** Free an AvahiAddressResolver object */
void avahi_address_resolver_free(AvahiAddressResolver *r);
/** The type of domain to browse for */
AVAHI_DOMAIN_BROWSER_REGISTER_DEFAULT, /**< Browse for the default registering domain */
AVAHI_DOMAIN_BROWSER_BROWSE, /**< Browse for a list of available browsing domains */
AVAHI_DOMAIN_BROWSER_BROWSE_DEFAULT, /**< Browse for the default browsing domain */
- AVAHI_DOMAIN_BROWSER_BROWSE_LEGACY /**< Legacy browse domain - see DNS-SD spec for more information */
+ AVAHI_DOMAIN_BROWSER_BROWSE_LEGACY, /**< Legacy browse domain - see DNS-SD spec for more information */
+ AVAHI_DOMAIN_BROWSER_MAX
} AvahiDomainBrowserType;
+/** A local domain browsing object. May be used to enumerate domains used on the local LAN */
typedef struct AvahiDomainBrowser AvahiDomainBrowser;
-typedef void (*AvahiDomainBrowserCallback)(AvahiDomainBrowser *b, gint interface, guchar protocol, AvahiBrowserEvent event, const gchar *domain, gpointer userdata);
-AvahiDomainBrowser *avahi_domain_browser_new(AvahiServer *server, gint interface, guchar protocol, const gchar *domain, AvahiDomainBrowserType type, AvahiDomainBrowserCallback callback, gpointer userdata);
+
+/** Callback prototype for AvahiDomainBrowser events */
+typedef void (*AvahiDomainBrowserCallback)(
+ AvahiDomainBrowser *b,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
+ AvahiBrowserEvent event,
+ const gchar *domain,
+ gpointer userdata);
+
+/** Create a new AvahiDomainBrowser object */
+AvahiDomainBrowser *avahi_domain_browser_new(
+ AvahiServer *server,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
+ const gchar *domain,
+ AvahiDomainBrowserType type,
+ AvahiDomainBrowserCallback callback,
+ gpointer userdata);
+
+/** Free an AvahiDomainBrowser object */
void avahi_domain_browser_free(AvahiDomainBrowser *b);
+/** A DNS-SD service type browsing object. May be used to enumerate the service types of all available services on the local LAN */
typedef struct AvahiServiceTypeBrowser AvahiServiceTypeBrowser;
-typedef void (*AvahiServiceTypeBrowserCallback)(AvahiServiceTypeBrowser *b, gint interface, guchar protocol, AvahiBrowserEvent event, const gchar *type, const gchar *domain, gpointer userdata);
-AvahiServiceTypeBrowser *avahi_service_type_browser_new(AvahiServer *server, gint interface, guchar protocol, const gchar *domain, AvahiServiceTypeBrowserCallback callback, gpointer userdata);
+
+/** Callback prototype for AvahiServiceTypeBrowser events */
+typedef void (*AvahiServiceTypeBrowserCallback)(
+ AvahiServiceTypeBrowser *b,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
+ AvahiBrowserEvent event,
+ const gchar *type,
+ const gchar *domain,
+ gpointer userdata);
+
+/** Create a new AvahiServiceTypeBrowser object. */
+AvahiServiceTypeBrowser *avahi_service_type_browser_new(
+ AvahiServer *server,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
+ const gchar *domain,
+ AvahiServiceTypeBrowserCallback callback,
+ gpointer userdata);
+
+/** Free an AvahiServiceTypeBrowser object */
void avahi_service_type_browser_free(AvahiServiceTypeBrowser *b);
+/** A DNS-SD service browser. Use this to enumerate available services of a certain kind on the local LAN. Use AvahiServiceResolver to get specific service data like address and port for a service. */
typedef struct AvahiServiceBrowser AvahiServiceBrowser;
-typedef void (*AvahiServiceBrowserCallback)(AvahiServiceBrowser *b, gint interface, guchar protocol, AvahiBrowserEvent event, const gchar *name, const gchar *type, const gchar *domain, gpointer userdata);
-AvahiServiceBrowser *avahi_service_browser_new(AvahiServer *server, gint interface, guchar protocol, const gchar *service_type, const gchar *domain, AvahiServiceBrowserCallback callback, gpointer userdata);
+
+/** Callback prototype for AvahiServiceBrowser events */
+typedef void (*AvahiServiceBrowserCallback)(
+ AvahiServiceBrowser *b,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
+ AvahiBrowserEvent event,
+ const gchar *name /**< Service name, e.g. "Lennart's Files" */,
+ const gchar *type /**< DNS-SD type, e.g. "_http._tcp" */,
+ const gchar *domain /**< Domain of this service, e.g. "local" */,
+ gpointer userdata);
+
+/** Create a new AvahiServiceBrowser object. */
+AvahiServiceBrowser *avahi_service_browser_new(
+ AvahiServer *server,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
+ const gchar *service_type /** DNS-SD service type, e.g. "_http._tcp" */,
+ const gchar *domain,
+ AvahiServiceBrowserCallback callback,
+ gpointer userdata);
+
+/** Free an AvahiServiceBrowser object */
void avahi_service_browser_free(AvahiServiceBrowser *b);
+/** A DNS-SD service resolver. Use this to retrieve addres, port and TXT data for a DNS-SD service */
typedef struct AvahiServiceResolver AvahiServiceResolver;
-typedef void (*AvahiServiceResolverCallback)(AvahiServiceResolver *r, gint interface, guchar protocol, AvahiResolverEvent event, const gchar *name, const gchar *type, const gchar *domain, const gchar *host_name, const AvahiAddress *a, guint16 port, AvahiStringList *txt, gpointer userdata);
-AvahiServiceResolver *avahi_service_resolver_new(AvahiServer *server, gint interface, guchar protocol, const gchar *name, const gchar *type, const gchar *domain, guchar aprotocol, AvahiServiceResolverCallback calback, gpointer userdata);
-void avahi_service_resolver_free(AvahiServiceResolver *r);
+/** Callback prototype for AvahiServiceResolver events */
+typedef void (*AvahiServiceResolverCallback)(
+ AvahiServiceResolver *r,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
+ AvahiResolverEvent event,
+ const gchar *name, /**< Service name */
+ const gchar *type, /**< Service Type */
+ const gchar *domain,
+ const gchar *host_name, /**< Host name of the service */
+ const AvahiAddress *a, /**< The resolved host name */
+ guint16 port, /**< Service name */
+ AvahiStringList *txt, /**< TXT record data */
+ gpointer userdata);
+
+/** Create a new AvahiServiceResolver object */
+AvahiServiceResolver *avahi_service_resolver_new(
+ AvahiServer *server,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
+ const gchar *name,
+ const gchar *type,
+ const gchar *domain,
+ AvahiProtocol aprotocol, /**< Address family of the desired service address. Use AVAHI_PROTO_UNSPEC if you don't care */
+ AvahiServiceResolverCallback calback,
+ gpointer userdata);
+
+/** Free an AvahiServiceResolver object */
+void avahi_service_resolver_free(AvahiServiceResolver *r);
/** A domain service browser object. Use this to browse for
* conventional unicast DNS servers which may be used to resolve
* conventional domain names */
typedef struct AvahiDNSServerBrowser AvahiDNSServerBrowser;
-typedef void (*AvahiDNSServerBrowserCallback)(AvahiDNSServerBrowser *b, gint interface, guchar protocol, AvahiBrowserEvent event, const gchar *host_name, const AvahiAddress *a, guint16 port, gpointer userdata);
-AvahiDNSServerBrowser *avahi_dns_server_browser_new(AvahiServer *server, gint interface, guchar protocol, const gchar *domain, AvahiDNSServerType type, guchar aprotocol, AvahiDNSServerBrowserCallback callback, gpointer userdata);
+
+/** Callback prototype for AvahiDNSServerBrowser events */
+typedef void (*AvahiDNSServerBrowserCallback)(
+ AvahiDNSServerBrowser *b,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
+ AvahiBrowserEvent event,
+ const gchar *host_name, /**< Host name of the DNS server, probably useless */
+ const AvahiAddress *a, /**< Address of the DNS server */
+ guint16 port, /**< Port number of the DNS servers, probably 53 */
+ gpointer userdata);
+
+/** Create a new AvahiDNSServerBrowser object */
+AvahiDNSServerBrowser *avahi_dns_server_browser_new(
+ AvahiServer *server,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
+ const gchar *domain,
+ AvahiDNSServerType type,
+ AvahiProtocol aprotocol, /**< Address protocol for the DNS server */
+ AvahiDNSServerBrowserCallback callback,
+ gpointer userdata);
+
+/** Free an AvahiDNSServerBrowser object */
void avahi_dns_server_browser_free(AvahiDNSServerBrowser *b);
+/** Return a human readable error string for the specified error code */
+const gchar *avahi_strerror(gint error);
+
+/** Return the last error code */
+gint avahi_server_errno(AvahiServer *s);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+AVAHI_C_DECL_END
+#endif
+
#endif
projects / catta / blobdiff