summaryrefslogtreecommitdiffstats
path: root/avahi-core/core.h
blob: e7e626892ff29bfea4d1acdcbaaf8991db1d0047 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
#ifndef foocorehfoo
#define foocorehfoo

/* $Id$ */

/***
  This file is part of avahi.
 
  avahi is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as
  published by the Free Software Foundation; either version 2.1 of the
  License, or (at your option) any later version.
 
  avahi is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
  Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with avahi; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  USA.
***/

#include <stdio.h>
#include <glib.h>

/** \file core.h The Avahi Multicast DNS and DNS Service Discovery implmentation. */

#include <avahi-common/cdecl.h>

AVAHI_C_DECL_BEGIN

/** An mDNS responder object */
typedef struct AvahiServer AvahiServer;

/** A locally registered DNS resource record */
typedef struct AvahiEntry AvahiEntry;

/** A group of locally registered DNS RRs */
typedef struct AvahiEntryGroup AvahiEntryGroup;

AVAHI_C_DECL_END

#include <avahi-common/address.h>
#include <avahi-common/rr.h>
#include <avahi-common/alternative.h>

AVAHI_C_DECL_BEGIN

/** 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 */
} AvahiServerState;

/** Flags for server entries */
typedef enum {
    AVAHI_ENTRY_NULL = 0,          /**< No special flags */
    AVAHI_ENTRY_UNIQUE = 1,        /**< The RRset is intended to be unique */
    AVAHI_ENTRY_NOPROBE = 2,       /**< Though the RRset is intended to be unique no probes shall be sent */
    AVAHI_ENTRY_NOANNOUNCE = 4,    /**< Do not announce this RR to other hosts */
    AVAHI_ENTRY_ALLOWMUTIPLE = 8   /**< Allow multiple local records of this type, even if they are intended to be unique */
} AvahiEntryFlags;

/** States of an entry group object */
typedef enum {
    AVAHI_ENTRY_GROUP_UNCOMMITED = -1,   /**< The group has not yet been commited, the user must still call avahi_entry_group_commit() */
    AVAHI_ENTRY_GROUP_REGISTERING = 0,   /**< The entries of the group are currently being registered */
    AVAHI_ENTRY_GROUP_ESTABLISHED,       /**< The entries have successfully been established */
    AVAHI_ENTRY_GROUP_COLLISION          /**< A name collision for one of the entries in the group has been detected, the entries have been withdrawn */ 
} AvahiEntryGroupState;

/** Prototype for callback functions which are called whenever the state of an AvahiServer object changes */
typedef void (*AvahiServerCallback) (AvahiServer *s, AvahiServerState state, gpointer userdata);

/** Prototype for callback functions which are called whenever the state of an AvahiEntryGroup object changes */
typedef void (*AvahiEntryGroupCallback) (AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, gpointer userdata);

/** Stores configuration options for a server instance */
typedef struct AvahiServerConfig {
    gchar *host_name;                      /**< Default host name. If left empty defaults to the result of gethostname(2) of the libc */
    gchar *domain_name;                    /**< Default domain name. If left empty defaults to .local */
    gboolean use_ipv4;                     /**< Enable IPv4 support */
    gboolean use_ipv6;                     /**< Enable IPv6 support */
    gboolean publish_hinfo;                /**< Register a HINFO record for the host containing the local OS and CPU type */
    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. 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 */
} AvahiServerConfig;

/** Allocate a new mDNS responder object. */
AvahiServer *avahi_server_new(
    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 */);

/** Free an mDNS responder object */
void avahi_server_free(AvahiServer* s);

/** Fill in default values for a server configuration structure. If you
 * make use of an AvahiServerConfig structure be sure to initialize
 * it with this function for the sake of upwards library
 * compatibility. This call may allocate strings on the heap. To
 * release this memory make sure to call
 * avahi_server_config_done(). If you want to replace any strings in
 * the structure be sure to free the strings filled in by this
 * function with g_free() first and allocate the replacements with
 * g_malloc() (or g_strdup()).*/
AvahiServerConfig* avahi_server_config_init(
   AvahiServerConfig *c /**< A structure which shall be filled in */ );

/** Make a deep copy of the configuration structure *c to *ret. */
AvahiServerConfig* avahi_server_config_copy(
    AvahiServerConfig *ret /**< destination */,
    const AvahiServerConfig *c /**< source */);

/** Free the data in a server configuration structure. */
void avahi_server_config_free(AvahiServerConfig *c);

/** Return the currently chosen domain name of the server object. The
 * return value points to an internally allocated string. Be sure to
 * make a copy of the string before calling any other library
 * functions. */
const gchar* avahi_server_get_domain_name(AvahiServer *s);

/** Return the currently chosen host name. The return value points to a internally allocated string. */
const gchar* avahi_server_get_host_name(AvahiServer *s);

/** Return the currently chosen host name as a FQDN ("fully qualified
 * domain name", i.e. the concatenation of the host and domain
 * name). The return value points to a internally allocated string. */
const gchar* avahi_server_get_host_name_fqdn(AvahiServer *s);

/** Change the host name of a running mDNS responder. This will drop
all automicatilly generated RRs and readd them with the new
name. Since the responder has to probe for the new RRs this function
takes some time to take effect altough it returns immediately. This
function is intended to be called when a host name conflict is
reported using AvahiServerCallback. The caller should readd all user
defined RRs too since they otherwise continue to point to the outdated
host name..*/
gint avahi_server_set_host_name(AvahiServer *s, const gchar *host_name);

/** Change the domain name of a running mDNS responder. The same rules
 * as with avahi_server_set_host_name() apply. */
gint avahi_server_set_domain_name(AvahiServer *s, const gchar *domain_name);

/** Return the opaque user data pointer attached to a server object */
gpointer avahi_server_get_data(AvahiServer *s);

/** Change the opaque user data pointer attached to a server object */
void avahi_server_set_data(AvahiServer *s, gpointer userdata);

/** Return the current state of the server object */
AvahiServerState avahi_server_get_state(AvahiServer *s);

/** Iterate through all local entries of the server. (when g is NULL)
 * or of a specified entry group. At the first call state should point
 * to a NULL initialized void pointer, That pointer is used to track
 * the current iteration. It is not safe to call any other
 * avahi_server_xxx() function during the iteration. If the last entry
 * 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);

/** Create a new entry group. The specified callback function is
 * called whenever the state of the group changes. Use entry group
 * objects to keep track of you RRs. Add new RRs to a group using
 * avahi_server_add_xxx(). Make sure to call avahi_entry_group_commit()
 * to start the registration process for your RRs */
AvahiEntryGroup *avahi_entry_group_new(AvahiServer *s, AvahiEntryGroupCallback callback, gpointer userdata);

/** Free an entry group. All RRs assigned to the group are removed from the server */
void avahi_entry_group_free(AvahiEntryGroup *g);

/** Commit an entry group. This starts the probing and registration process for all RRs in the group */
gint avahi_entry_group_commit(AvahiEntryGroup *g);

/** Return the current state of the specified entry group */
AvahiEntryGroupState avahi_entry_group_get_state(AvahiEntryGroup *g);

/** Change the opaque user data pointer attached to an entry group object */
void avahi_entry_group_set_data(AvahiEntryGroup *g, gpointer userdata);

/** 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,           /**< 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,
    AvahiIfIndex interface,
    AvahiProtocol protocol,
    AvahiEntryFlags flags,
    guint32 ttl,             /**< DNS TTL for this record */
    const gchar *name,       /**< PTR record name */
    const gchar *dest        /**< pointer destination */  );

/** Add a PTR RR to the server. See avahi_server_add() for more information. */
gint avahi_server_add_txt(
    AvahiServer *s,
    AvahiEntryGroup *g,
    AvahiIfIndex interface,
    AvahiProtocol protocol,
    AvahiEntryFlags flags,
    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,
    AvahiIfIndex interface,
    AvahiProtocol protocol,
    AvahiEntryFlags flags,
    guint32 ttl,
    const gchar *name,
    va_list 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,
    AvahiIfIndex interface,
    AvahiProtocol protocol,
    AvahiEntryFlags flags,
    guint32 ttl,
    const gchar *name,
    AvahiStringList *strlst  /**< TXT decord data as a AvahiString. Only the pointer to the object and not the object itself is copied into the RR. Therefore you should not free the strlst object yourself, this will be done by the library. If you want to add multiple records with the same RR data you MUST copy the strlst object prior to calling this function with avahi_strlst_copy(). */ );

/** 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,
    AvahiIfIndex interface,
    AvahiProtocol protocol,
    AvahiEntryFlags flags,
    const gchar *name,
    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,
    AvahiIfIndex interface,
    AvahiProtocol protocol,
    const gchar *type,         /**< DNS-SD type, e.g. "_http._tcp" */
    const gchar *name,         /**< Service name, e.g. "Lennart's Files" */
    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,
    AvahiIfIndex interface,
    AvahiProtocol protocol,
    const gchar *type,
    const gchar *name,
    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 not copied. You need to make a copy if this object if you want to reuse it. The object is freed if the RR is removed from the server. */
gint avahi_server_add_service_strlst(
    AvahiServer *s,
    AvahiEntryGroup *g,
    AvahiIfIndex interface,
    AvahiProtocol protocol,
    const gchar *type,
    const gchar *name,
    const gchar *domain,
    const gchar *host,
    guint16 port,
    AvahiStringList *strlst);

/** The type of DNS server */
typedef enum {
    AVAHI_DNS_SERVER_RESOLVE,         /**< Unicast DNS servers for normal resolves (_domain._udp)*/
    AVAHI_DNS_SERVER_UPDATE           /**< Unicast DNS servers for updates (_dns-update._udp)*/
} AvahiDNSServerType;

/** Publish the specified unicast DNS server address via mDNS. You may
 * browse for records create this way wit
 * avahi_dns_server_browser_new(). */
gint avahi_server_add_dns_server_address(
    AvahiServer *s,
    AvahiEntryGroup *g,
    AvahiIfIndex interface,
    AvahiProtocol protocol,
    const gchar *domain,
    AvahiDNSServerType type,
    const AvahiAddress *address,
    guint16 port /** should be 53 */);

/** Similar to avahi_server_add_dns_server_address(), but specify a
host name instead of an address. The specified host name should be
resolvable via mDNS */
gint avahi_server_add_dns_server_name(
    AvahiServer *s,
    AvahiEntryGroup *g,
    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,            /**< 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,         /**< 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;

/** 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;

/** 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;

/** 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 */
typedef enum {
    AVAHI_DOMAIN_BROWSER_REGISTER,          /**< Browse for a list of available registering domains */
    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 */
} AvahiDomainBrowserType;

/** A local domain browsing object. May be used to enumerate domains used on the local LAN */
typedef struct AvahiDomainBrowser AvahiDomainBrowser;

/** 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;

/** 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;

/** 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;

/** 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;

/** 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);

AVAHI_C_DECL_END

#endif