7 This file is part of avahi.
9 avahi is free software; you can redistribute it and/or modify it
10 under the terms of the GNU Lesser General Public License as
11 published by the Free Software Foundation; either version 2.1 of the
12 License, or (at your option) any later version.
14 avahi is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
17 Public License for more details.
19 You should have received a copy of the GNU Lesser General Public
20 License along with avahi; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
27 /** \file core.h The Avahi Multicast DNS and DNS Service Discovery implmentation. */
29 /** \example publish-service.c Example how to register a DNS-SD
30 * service using an embedded mDNS stack. It behaves like a network
31 * printer registering both an IPP and a BSD LPR service. */
33 /** \example browse-services.c Example how to browse for DNS-SD
34 * services using an embedded mDNS stack. */
36 #include <avahi-common/cdecl.h>
38 #ifndef DOXYGEN_SHOULD_SKIP_THIS
42 /** An mDNS responder object */
43 typedef struct AvahiServer AvahiServer;
45 /** A locally registered DNS resource record */
46 typedef struct AvahiEntry AvahiEntry;
48 /** A group of locally registered DNS RRs */
49 typedef struct AvahiEntryGroup AvahiEntryGroup;
51 #ifndef DOXYGEN_SHOULD_SKIP_THIS
55 #include <avahi-common/address.h>
56 #include <avahi-common/rr.h>
57 #include <avahi-common/alternative.h>
59 #ifndef DOXYGEN_SHOULD_SKIP_THIS
63 /** Error codes used by avahi */
65 AVAHI_OK = 0, /**< OK */
66 AVAHI_ERR_FAILURE = -1, /**< Generic error code */
67 AVAHI_ERR_BAD_STATE = -2, /**< Object was in a bad state */
68 AVAHI_ERR_INVALID_HOST_NAME = -3, /**< Invalid host name */
69 AVAHI_ERR_INVALID_DOMAIN_NAME = -4, /**< Invalid domain name */
70 AVAHI_ERR_NO_NETWORK = -5, /**< No suitable network protocol available */
71 AVAHI_ERR_INVALID_TTL = -6, /**< Invalid DNS TTL */
72 AVAHI_ERR_IS_PATTERN = -7, /**< RR key is pattern */
73 AVAHI_ERR_LOCAL_COLLISION = -8, /**< Local name collision */
74 AVAHI_ERR_INVALID_RECORD = -9, /**< Invalid RR */
75 AVAHI_ERR_INVALID_SERVICE_NAME = -10, /**< Invalid service name */
76 AVAHI_ERR_INVALID_SERVICE_TYPE = -11, /**< Invalid service type */
77 AVAHI_ERR_INVALID_PORT = -12, /**< Invalid port number */
78 AVAHI_ERR_INVALID_KEY = -13, /**< Invalid key */
79 AVAHI_ERR_INVALID_ADDRESS = -14, /**< Invalid address */
80 AVAHI_ERR_TIMEOUT = -15, /**< Timeout reached */
81 AVAHI_ERR_TOO_MANY_CLIENTS = -16, /**< Too many clients */
82 AVAHI_ERR_TOO_MANY_OBJECTS = -17, /**< Too many objects */
83 AVAHI_ERR_TOO_MANY_ENTRIES = -18, /**< Too many entries */
84 AVAHI_ERR_OS = -19, /**< OS error */
85 AVAHI_ERR_ACCESS_DENIED = -20, /**< Access denied */
86 AVAHI_ERR_INVALID_OPERATION = -21, /**< Invalid operation */
90 /** States of a server object */
92 AVAHI_SERVER_INVALID = -1, /**< Invalid state (initial) */
93 AVAHI_SERVER_REGISTERING = 0, /**< Host RRs are being registered */
94 AVAHI_SERVER_RUNNING, /**< All host RRs have been established */
95 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() */
98 /** Flags for server entries */
100 AVAHI_ENTRY_NULL = 0, /**< No special flags */
101 AVAHI_ENTRY_UNIQUE = 1, /**< The RRset is intended to be unique */
102 AVAHI_ENTRY_NOPROBE = 2, /**< Though the RRset is intended to be unique no probes shall be sent */
103 AVAHI_ENTRY_NOANNOUNCE = 4, /**< Do not announce this RR to other hosts */
104 AVAHI_ENTRY_ALLOWMUTIPLE = 8 /**< Allow multiple local records of this type, even if they are intended to be unique */
107 /** States of an entry group object */
109 AVAHI_ENTRY_GROUP_UNCOMMITED = -1, /**< The group has not yet been commited, the user must still call avahi_entry_group_commit() */
110 AVAHI_ENTRY_GROUP_REGISTERING = 0, /**< The entries of the group are currently being registered */
111 AVAHI_ENTRY_GROUP_ESTABLISHED, /**< The entries have successfully been established */
112 AVAHI_ENTRY_GROUP_COLLISION /**< A name collision for one of the entries in the group has been detected, the entries have been withdrawn */
113 } AvahiEntryGroupState;
115 /** Prototype for callback functions which are called whenever the state of an AvahiServer object changes */
116 typedef void (*AvahiServerCallback) (AvahiServer *s, AvahiServerState state, gpointer userdata);
118 /** Prototype for callback functions which are called whenever the state of an AvahiEntryGroup object changes */
119 typedef void (*AvahiEntryGroupCallback) (AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, gpointer userdata);
121 /** Stores configuration options for a server instance */
122 typedef struct AvahiServerConfig {
123 gchar *host_name; /**< Default host name. If left empty defaults to the result of gethostname(2) of the libc */
124 gchar *domain_name; /**< Default domain name. If left empty defaults to .local */
125 gboolean use_ipv4; /**< Enable IPv4 support */
126 gboolean use_ipv6; /**< Enable IPv6 support */
127 gboolean publish_hinfo; /**< Register a HINFO record for the host containing the local OS and CPU type */
128 gboolean publish_addresses; /**< Register A, AAAA and PTR records for all local IP addresses */
129 gboolean publish_workstation; /**< Register a _workstation._tcp service */
130 gboolean publish_domain; /**< Announce the local domain for browsing */
131 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. */
132 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. */
133 gboolean enable_reflector; /**< Reflect incoming mDNS traffic to all local networks. This allows mDNS based network browsing beyond ethernet borders */
134 gboolean reflect_ipv; /**< if enable_reflector is TRUE, enable/disable reflecting between IPv4 and IPv6 */
137 /** Allocate a new mDNS responder object. */
138 AvahiServer *avahi_server_new(
139 GMainContext *c, /**< The GLIB main loop context to attach to */
140 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. */
141 AvahiServerCallback callback, /**< A callback which is called whenever the state of the server changes */
142 gpointer userdata, /**< An opaque pointer which is passed to the callback function */
145 /** Free an mDNS responder object */
146 void avahi_server_free(AvahiServer* s);
148 /** Fill in default values for a server configuration structure. If you
149 * make use of an AvahiServerConfig structure be sure to initialize
150 * it with this function for the sake of upwards library
151 * compatibility. This call may allocate strings on the heap. To
152 * release this memory make sure to call
153 * avahi_server_config_done(). If you want to replace any strings in
154 * the structure be sure to free the strings filled in by this
155 * function with g_free() first and allocate the replacements with
156 * g_malloc() (or g_strdup()).*/
157 AvahiServerConfig* avahi_server_config_init(
158 AvahiServerConfig *c /**< A structure which shall be filled in */ );
160 /** Make a deep copy of the configuration structure *c to *ret. */
161 AvahiServerConfig* avahi_server_config_copy(
162 AvahiServerConfig *ret /**< destination */,
163 const AvahiServerConfig *c /**< source */);
165 /** Free the data in a server configuration structure. */
166 void avahi_server_config_free(AvahiServerConfig *c);
168 /** Return the currently chosen domain name of the server object. The
169 * return value points to an internally allocated string. Be sure to
170 * make a copy of the string before calling any other library
172 const gchar* avahi_server_get_domain_name(AvahiServer *s);
174 /** Return the currently chosen host name. The return value points to a internally allocated string. */
175 const gchar* avahi_server_get_host_name(AvahiServer *s);
177 /** Return the currently chosen host name as a FQDN ("fully qualified
178 * domain name", i.e. the concatenation of the host and domain
179 * name). The return value points to a internally allocated string. */
180 const gchar* avahi_server_get_host_name_fqdn(AvahiServer *s);
182 /** Change the host name of a running mDNS responder. This will drop
183 all automicatilly generated RRs and readd them with the new
184 name. Since the responder has to probe for the new RRs this function
185 takes some time to take effect altough it returns immediately. This
186 function is intended to be called when a host name conflict is
187 reported using AvahiServerCallback. The caller should readd all user
188 defined RRs too since they otherwise continue to point to the outdated
190 gint avahi_server_set_host_name(AvahiServer *s, const gchar *host_name);
192 /** Change the domain name of a running mDNS responder. The same rules
193 * as with avahi_server_set_host_name() apply. */
194 gint avahi_server_set_domain_name(AvahiServer *s, const gchar *domain_name);
196 /** Return the opaque user data pointer attached to a server object */
197 gpointer avahi_server_get_data(AvahiServer *s);
199 /** Change the opaque user data pointer attached to a server object */
200 void avahi_server_set_data(AvahiServer *s, gpointer userdata);
202 /** Return the current state of the server object */
203 AvahiServerState avahi_server_get_state(AvahiServer *s);
205 /** Iterate through all local entries of the server. (when g is NULL)
206 * or of a specified entry group. At the first call state should point
207 * to a NULL initialized void pointer, That pointer is used to track
208 * the current iteration. It is not safe to call any other
209 * avahi_server_xxx() function during the iteration. If the last entry
210 * has been read, NULL is returned. */
211 const AvahiRecord *avahi_server_iterate(AvahiServer *s, AvahiEntryGroup *g, void **state);
213 /** Callback prototype for avahi_server_dump() */
214 typedef void (*AvahiDumpCallback)(const gchar *text, gpointer userdata);
216 /** Dump the current server status by calling "callback" for each line. */
217 void avahi_server_dump(AvahiServer *s, AvahiDumpCallback callback, gpointer userdata);
219 /** Create a new entry group. The specified callback function is
220 * called whenever the state of the group changes. Use entry group
221 * objects to keep track of you RRs. Add new RRs to a group using
222 * avahi_server_add_xxx(). Make sure to call avahi_entry_group_commit()
223 * to start the registration process for your RRs */
224 AvahiEntryGroup *avahi_entry_group_new(AvahiServer *s, AvahiEntryGroupCallback callback, gpointer userdata);
226 /** Free an entry group. All RRs assigned to the group are removed from the server */
227 void avahi_entry_group_free(AvahiEntryGroup *g);
229 /** Commit an entry group. This starts the probing and registration process for all RRs in the group */
230 gint avahi_entry_group_commit(AvahiEntryGroup *g);
232 /** Remove all entries from the entry group and reset the state to AVAHI_ENTRY_GROUP_UNCOMMITED. */
233 void avahi_entry_group_reset(AvahiEntryGroup *g);
235 /** Return TRUE if the entry group is empty, i.e. has no records attached. */
236 gboolean avahi_entry_group_is_empty(AvahiEntryGroup *g);
238 /** Return the current state of the specified entry group */
239 AvahiEntryGroupState avahi_entry_group_get_state(AvahiEntryGroup *g);
241 /** Change the opaque user data pointer attached to an entry group object */
242 void avahi_entry_group_set_data(AvahiEntryGroup *g, gpointer userdata);
244 /** Return the opaque user data pointer currently set for the entry group object */
245 gpointer avahi_entry_group_get_data(AvahiEntryGroup *g);
247 /** Add a new resource record to the server. Returns 0 on success, negative otherwise. */
248 gint avahi_server_add(
249 AvahiServer *s, /**< The server object to add this record to */
250 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. */
251 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 */
252 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). */
253 AvahiEntryFlags flags, /**< Special flags for this record */
254 AvahiRecord *r /**< The record to add. This function increases the reference counter of this object. */ );
256 /** Add a PTR RR to the server. See avahi_server_add() for more information. */
257 gint avahi_server_add_ptr(
260 AvahiIfIndex interface,
261 AvahiProtocol protocol,
262 AvahiEntryFlags flags,
263 guint32 ttl, /**< DNS TTL for this record */
264 const gchar *name, /**< PTR record name */
265 const gchar *dest /**< pointer destination */ );
267 /** Add a PTR RR to the server. See avahi_server_add() for more information. */
268 gint avahi_server_add_txt(
271 AvahiIfIndex interface,
272 AvahiProtocol protocol,
273 AvahiEntryFlags flags,
274 guint32 ttl, /**< DNS TTL for this record */
275 const gchar *name, /**< TXT record name */
276 ... /**< Text record data, terminated by NULL */);
278 /** Add a PTR RR to the server. Mostly identical to
279 * avahi_server_add_text but takes a va_list instead of a variable
280 * number of arguments */
281 gint avahi_server_add_txt_va(
284 AvahiIfIndex interface,
285 AvahiProtocol protocol,
286 AvahiEntryFlags flags,
291 /** Add a PTR RR to the server. Mostly identical to
292 * avahi_server_add_text but takes an AvahiStringList record instead of a variable
293 * number of arguments. */
294 gint avahi_server_add_txt_strlst(
297 AvahiIfIndex interface,
298 AvahiProtocol protocol,
299 AvahiEntryFlags flags,
302 AvahiStringList *strlst /**< TXT decord data as a AvahiString. This routine makes a deep copy of this object. */ );
304 /** Add an IP address mapping to the server. This will add both the
305 * host-name-to-address and the reverse mapping to the server. See
306 * avahi_server_add() for more information. If adding one of the RRs
307 * fails, the function returns with an error, but it is not defined if
308 * the other RR is deleted from the server or not. Therefore, you have
309 * to free the AvahiEntryGroup and create a new one before
311 gint avahi_server_add_address(
314 AvahiIfIndex interface,
315 AvahiProtocol protocol,
316 AvahiEntryFlags flags,
320 /** Add an DNS-SD service to the Server. This will add all required
321 * RRs to the server. See avahi_server_add() for more information. If
322 * adding one of the RRs fails, the function returns with an error,
323 * but it is not defined if the other RR is deleted from the server or
324 * not. Therefore, you have to free the AvahiEntryGroup and create a
325 * new one before proceeding. */
326 gint avahi_server_add_service(
329 AvahiIfIndex interface,
330 AvahiProtocol protocol,
331 const gchar *name, /**< Service name, e.g. "Lennart's Files" */
332 const gchar *type, /**< DNS-SD type, e.g. "_http._tcp" */
334 const gchar *host, /**< Host name where this servcie resides, or NULL if on the local host */
335 guint16 port, /**< Port number of the service */
336 ... /**< Text records, terminated by NULL */);
338 /** Mostly identical to avahi_server_add_service(), but takes an va_list for the TXT records. */
339 gint avahi_server_add_service_va(
342 AvahiIfIndex interface,
343 AvahiProtocol protocol,
351 /** Mostly identical to avahi_server_add_service(), but takes an AvahiStringList object for the TXT records. The AvahiStringList object is copied. */
352 gint avahi_server_add_service_strlst(
355 AvahiIfIndex interface,
356 AvahiProtocol protocol,
362 AvahiStringList *strlst);
364 /** The type of DNS server */
366 AVAHI_DNS_SERVER_RESOLVE, /**< Unicast DNS servers for normal resolves (_domain._udp)*/
367 AVAHI_DNS_SERVER_UPDATE /**< Unicast DNS servers for updates (_dns-update._udp)*/
368 } AvahiDNSServerType;
370 /** Publish the specified unicast DNS server address via mDNS. You may
371 * browse for records create this way wit
372 * avahi_dns_server_browser_new(). */
373 gint avahi_server_add_dns_server_address(
376 AvahiIfIndex interface,
377 AvahiProtocol protocol,
379 AvahiDNSServerType type,
380 const AvahiAddress *address,
381 guint16 port /** should be 53 */);
383 /** Similar to avahi_server_add_dns_server_address(), but specify a
384 host name instead of an address. The specified host name should be
385 resolvable via mDNS */
386 gint avahi_server_add_dns_server_name(
389 AvahiIfIndex interface,
390 AvahiProtocol protocol,
392 AvahiDNSServerType type,
394 guint16 port /** should be 53 */);
396 /** Type of callback event when browsing */
398 AVAHI_BROWSER_NEW = 0, /**< The object is new on the network */
399 AVAHI_BROWSER_REMOVE = -1 /**< The object has been removed from the network */
402 /** Type of callback event when resolving */
404 AVAHI_RESOLVER_FOUND = 0, /**< RR found, resolving successful */
405 AVAHI_RESOLVER_TIMEOUT = -1 /**< Noone responded within the timeout, resolving failed */
406 } AvahiResolverEvent;
408 /** A browsing object for arbitrary RRs */
409 typedef struct AvahiRecordBrowser AvahiRecordBrowser;
411 /** Callback prototype for AvahiRecordBrowser events */
412 typedef void (*AvahiRecordBrowserCallback)(
413 AvahiRecordBrowser *b, /**< The AvahiRecordBrowser object that is emitting this callback */
414 AvahiIfIndex interface, /**< Logical OS network interface number the record was found on */
415 AvahiProtocol protocol, /**< Protocol number the record was found. */
416 AvahiBrowserEvent event, /**< Browsing event, either AVAHI_BROWSER_NEW or AVAHI_BROWSER_REMOVE */
417 AvahiRecord *record, /**< The record that was found */
418 gpointer userdata /**< Arbitrary user data passed to avahi_record_browser_new() */ );
420 /** Create a new browsing object for arbitrary RRs */
421 AvahiRecordBrowser *avahi_record_browser_new(
422 AvahiServer *server, /**< The server object to which attach this query */
423 AvahiIfIndex interface, /**< Logical OS interface number where to look for the records, or AVAHI_IF_UNSPEC to look on interfaces */
424 AvahiProtocol protocol, /**< Protocol number to use when looking for the record, or AVAHI_PROTO_UNSPEC to look on all protocols */
425 AvahiKey *key, /**< The search key */
426 AvahiRecordBrowserCallback callback, /**< The callback to call on browsing events */
427 gpointer userdata /**< Arbitrary use suppliable data which is passed to the callback */);
429 /** Free an AvahiRecordBrowser object */
430 void avahi_record_browser_free(AvahiRecordBrowser *b);
432 /** A host name to IP adddress resolver object */
433 typedef struct AvahiHostNameResolver AvahiHostNameResolver;
435 /** Callback prototype for AvahiHostNameResolver events */
436 typedef void (*AvahiHostNameResolverCallback)(
437 AvahiHostNameResolver *r,
438 AvahiIfIndex interface,
439 AvahiProtocol protocol,
440 AvahiResolverEvent event, /**< Resolving event */
441 const gchar *host_name, /**< Host name which should be resolved. May differ in case from the query */
442 const AvahiAddress *a, /**< The address, or NULL if the host name couldn't be resolved. */
445 /** Create an AvahiHostNameResolver object for resolving a host name to an adddress. See AvahiRecordBrowser for more info on the paramters. */
446 AvahiHostNameResolver *avahi_host_name_resolver_new(
448 AvahiIfIndex interface,
449 AvahiProtocol protocol,
450 const gchar *host_name, /**< The host name to look for */
451 AvahiProtocol aprotocol, /**< The address family of the desired address or AVAHI_PROTO_UNSPEC if doesn't matter. */
452 AvahiHostNameResolverCallback calback,
455 /** Free a AvahiHostNameResolver object */
456 void avahi_host_name_resolver_free(AvahiHostNameResolver *r);
458 /** An IP address to host name resolver object ("reverse lookup") */
459 typedef struct AvahiAddressResolver AvahiAddressResolver;
461 /** Callback prototype for AvahiAddressResolver events */
462 typedef void (*AvahiAddressResolverCallback)(
463 AvahiAddressResolver *r,
464 AvahiIfIndex interface,
465 AvahiProtocol protocol,
466 AvahiResolverEvent event,
467 const AvahiAddress *a,
468 const gchar *host_name, /**< A host name for the specified address, if one was found, i.e. event == AVAHI_RESOLVER_FOUND */
471 /** Create an AvahiAddressResolver object. See AvahiRecordBrowser for more info on the paramters. */
472 AvahiAddressResolver *avahi_address_resolver_new(
474 AvahiIfIndex interface,
475 AvahiProtocol protocol,
476 const AvahiAddress *address,
477 AvahiAddressResolverCallback calback,
480 /** Free an AvahiAddressResolver object */
481 void avahi_address_resolver_free(AvahiAddressResolver *r);
483 /** The type of domain to browse for */
485 AVAHI_DOMAIN_BROWSER_REGISTER, /**< Browse for a list of available registering domains */
486 AVAHI_DOMAIN_BROWSER_REGISTER_DEFAULT, /**< Browse for the default registering domain */
487 AVAHI_DOMAIN_BROWSER_BROWSE, /**< Browse for a list of available browsing domains */
488 AVAHI_DOMAIN_BROWSER_BROWSE_DEFAULT, /**< Browse for the default browsing domain */
489 AVAHI_DOMAIN_BROWSER_BROWSE_LEGACY, /**< Legacy browse domain - see DNS-SD spec for more information */
490 AVAHI_DOMAIN_BROWSER_MAX
491 } AvahiDomainBrowserType;
493 /** A local domain browsing object. May be used to enumerate domains used on the local LAN */
494 typedef struct AvahiDomainBrowser AvahiDomainBrowser;
496 /** Callback prototype for AvahiDomainBrowser events */
497 typedef void (*AvahiDomainBrowserCallback)(
498 AvahiDomainBrowser *b,
499 AvahiIfIndex interface,
500 AvahiProtocol protocol,
501 AvahiBrowserEvent event,
505 /** Create a new AvahiDomainBrowser object */
506 AvahiDomainBrowser *avahi_domain_browser_new(
508 AvahiIfIndex interface,
509 AvahiProtocol protocol,
511 AvahiDomainBrowserType type,
512 AvahiDomainBrowserCallback callback,
515 /** Free an AvahiDomainBrowser object */
516 void avahi_domain_browser_free(AvahiDomainBrowser *b);
518 /** A DNS-SD service type browsing object. May be used to enumerate the service types of all available services on the local LAN */
519 typedef struct AvahiServiceTypeBrowser AvahiServiceTypeBrowser;
521 /** Callback prototype for AvahiServiceTypeBrowser events */
522 typedef void (*AvahiServiceTypeBrowserCallback)(
523 AvahiServiceTypeBrowser *b,
524 AvahiIfIndex interface,
525 AvahiProtocol protocol,
526 AvahiBrowserEvent event,
531 /** Create a new AvahiServiceTypeBrowser object. */
532 AvahiServiceTypeBrowser *avahi_service_type_browser_new(
534 AvahiIfIndex interface,
535 AvahiProtocol protocol,
537 AvahiServiceTypeBrowserCallback callback,
540 /** Free an AvahiServiceTypeBrowser object */
541 void avahi_service_type_browser_free(AvahiServiceTypeBrowser *b);
543 /** 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. */
544 typedef struct AvahiServiceBrowser AvahiServiceBrowser;
546 /** Callback prototype for AvahiServiceBrowser events */
547 typedef void (*AvahiServiceBrowserCallback)(
548 AvahiServiceBrowser *b,
549 AvahiIfIndex interface,
550 AvahiProtocol protocol,
551 AvahiBrowserEvent event,
552 const gchar *name /**< Service name, e.g. "Lennart's Files" */,
553 const gchar *type /**< DNS-SD type, e.g. "_http._tcp" */,
554 const gchar *domain /**< Domain of this service, e.g. "local" */,
557 /** Create a new AvahiServiceBrowser object. */
558 AvahiServiceBrowser *avahi_service_browser_new(
560 AvahiIfIndex interface,
561 AvahiProtocol protocol,
562 const gchar *service_type /** DNS-SD service type, e.g. "_http._tcp" */,
564 AvahiServiceBrowserCallback callback,
567 /** Free an AvahiServiceBrowser object */
568 void avahi_service_browser_free(AvahiServiceBrowser *b);
570 /** A DNS-SD service resolver. Use this to retrieve addres, port and TXT data for a DNS-SD service */
571 typedef struct AvahiServiceResolver AvahiServiceResolver;
573 /** Callback prototype for AvahiServiceResolver events */
574 typedef void (*AvahiServiceResolverCallback)(
575 AvahiServiceResolver *r,
576 AvahiIfIndex interface,
577 AvahiProtocol protocol,
578 AvahiResolverEvent event,
579 const gchar *name, /**< Service name */
580 const gchar *type, /**< Service Type */
582 const gchar *host_name, /**< Host name of the service */
583 const AvahiAddress *a, /**< The resolved host name */
584 guint16 port, /**< Service name */
585 AvahiStringList *txt, /**< TXT record data */
588 /** Create a new AvahiServiceResolver object */
589 AvahiServiceResolver *avahi_service_resolver_new(
591 AvahiIfIndex interface,
592 AvahiProtocol protocol,
596 AvahiProtocol aprotocol, /**< Address family of the desired service address. Use AVAHI_PROTO_UNSPEC if you don't care */
597 AvahiServiceResolverCallback calback,
600 /** Free an AvahiServiceResolver object */
601 void avahi_service_resolver_free(AvahiServiceResolver *r);
603 /** A domain service browser object. Use this to browse for
604 * conventional unicast DNS servers which may be used to resolve
605 * conventional domain names */
606 typedef struct AvahiDNSServerBrowser AvahiDNSServerBrowser;
608 /** Callback prototype for AvahiDNSServerBrowser events */
609 typedef void (*AvahiDNSServerBrowserCallback)(
610 AvahiDNSServerBrowser *b,
611 AvahiIfIndex interface,
612 AvahiProtocol protocol,
613 AvahiBrowserEvent event,
614 const gchar *host_name, /**< Host name of the DNS server, probably useless */
615 const AvahiAddress *a, /**< Address of the DNS server */
616 guint16 port, /**< Port number of the DNS servers, probably 53 */
619 /** Create a new AvahiDNSServerBrowser object */
620 AvahiDNSServerBrowser *avahi_dns_server_browser_new(
622 AvahiIfIndex interface,
623 AvahiProtocol protocol,
625 AvahiDNSServerType type,
626 AvahiProtocol aprotocol, /**< Address protocol for the DNS server */
627 AvahiDNSServerBrowserCallback callback,
630 /** Free an AvahiDNSServerBrowser object */
631 void avahi_dns_server_browser_free(AvahiDNSServerBrowser *b);
633 /** Return a human readable error string for the specified error code */
634 const gchar *avahi_strerror(gint error);
636 /** Return the last error code */
637 gint avahi_server_errno(AvahiServer *s);
639 #ifndef DOXYGEN_SHOULD_SKIP_THIS