git.meshlink.io Git - catta/blob - avahi-core/core.h

   1 #ifndef foocorehfoo
   2 #define foocorehfoo
   3
   4 /* $Id$ */
   5
   6 /***
   7   This file is part of avahi.
   8
   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.
  13
  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.
  18
  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
  22   USA.
  23 ***/
  24
  25 #include <glib.h>
  26
  27 /** \file core.h The Avahi Multicast DNS and DNS Service Discovery implmentation. */
  28
  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. */
  32
  33 /** \example browse-services.c Example how to browse for DNS-SD
  34  * services using an embedded mDNS stack. */
  35
  36 #include <avahi-common/cdecl.h>
  37
  38 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  39 AVAHI_C_DECL_BEGIN
  40 #endif
  41
  42 /** An mDNS responder object */
  43 typedef struct AvahiServer AvahiServer;
  44
  45 /** A locally registered DNS resource record */
  46 typedef struct AvahiEntry AvahiEntry;
  47
  48 /** A group of locally registered DNS RRs */
  49 typedef struct AvahiEntryGroup AvahiEntryGroup;
  50
  51 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  52 AVAHI_C_DECL_END
  53 #endif
  54
  55 #include <avahi-common/address.h>
  56 #include <avahi-common/rr.h>
  57 #include <avahi-common/alternative.h>
  58
  59 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  60 AVAHI_C_DECL_BEGIN
  61 #endif
  62
  63 /** Error codes used by avahi */
  64 enum {
  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 */
  87     AVAHI_ERR_MAX = -22
  88 };
  89
  90 /** States of a server object */
  91 typedef enum {
  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() */
  96 } AvahiServerState;
  97
  98 /** Flags for server entries */
  99 typedef enum {
 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 */
 105 } AvahiEntryFlags;
 106
 107 /** States of an entry group object */
 108 typedef enum {
 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;
 114
 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);
 117
 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);
 120
 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 */
 135 } AvahiServerConfig;
 136
 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 */
 143     gint *error);
 144
 145 /** Free an mDNS responder object */
 146 void avahi_server_free(AvahiServer* s);
 147
 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 */ );
 159
 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 */);
 164
 165 /** Free the data in a server configuration structure. */
 166 void avahi_server_config_free(AvahiServerConfig *c);
 167
 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
 171  * functions. */
 172 const gchar* avahi_server_get_domain_name(AvahiServer *s);
 173
 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);
 176
 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);
 181
 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
 189 host name..*/
 190 gint avahi_server_set_host_name(AvahiServer *s, const gchar *host_name);
 191
 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);
 195
 196 /** Return the opaque user data pointer attached to a server object */
 197 gpointer avahi_server_get_data(AvahiServer *s);
 198
 199 /** Change the opaque user data pointer attached to a server object */
 200 void avahi_server_set_data(AvahiServer *s, gpointer userdata);
 201
 202 /** Return the current state of the server object */
 203 AvahiServerState avahi_server_get_state(AvahiServer *s);
 204
 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);
 212
 213 /** Callback prototype for avahi_server_dump() */
 214 typedef void (*AvahiDumpCallback)(const gchar *text, gpointer userdata);
 215
 216 /** Dump the current server status by calling "callback" for each line.  */
 217 void avahi_server_dump(AvahiServer *s, AvahiDumpCallback callback, gpointer userdata);
 218
 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);
 225
 226 /** Free an entry group. All RRs assigned to the group are removed from the server */
 227 void avahi_entry_group_free(AvahiEntryGroup *g);
 228
 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);
 231
 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);
 234
 235 /** Return TRUE if the entry group is empty, i.e. has no records attached. */
 236 gboolean avahi_entry_group_is_empty(AvahiEntryGroup *g);
 237
 238 /** Return the current state of the specified entry group */
 239 AvahiEntryGroupState avahi_entry_group_get_state(AvahiEntryGroup *g);
 240
 241 /** Change the opaque user data pointer attached to an entry group object */
 242 void avahi_entry_group_set_data(AvahiEntryGroup *g, gpointer userdata);
 243
 244 /** Return the opaque user data pointer currently set for the entry group object */
 245 gpointer avahi_entry_group_get_data(AvahiEntryGroup *g);
 246
 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. */   );
 255
 256 /** Add a PTR RR to the server. See avahi_server_add() for more information. */
 257 gint avahi_server_add_ptr(
 258     AvahiServer *s,
 259     AvahiEntryGroup *g,
 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 */  );
 266
 267 /** Add a PTR RR to the server. See avahi_server_add() for more information. */
 268 gint avahi_server_add_txt(
 269     AvahiServer *s,
 270     AvahiEntryGroup *g,
 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 */);
 277
 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(
 282     AvahiServer *s,
 283     AvahiEntryGroup *g,
 284     AvahiIfIndex interface,
 285     AvahiProtocol protocol,
 286     AvahiEntryFlags flags,
 287     guint32 ttl,
 288     const gchar *name,
 289     va_list va);
 290
 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(
 295     AvahiServer *s,
 296     AvahiEntryGroup *g,
 297     AvahiIfIndex interface,
 298     AvahiProtocol protocol,
 299     AvahiEntryFlags flags,
 300     guint32 ttl,
 301     const gchar *name,
 302     AvahiStringList *strlst  /**< TXT decord data as a AvahiString. This routine makes a deep copy of this object. */ );
 303
 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
 310  * proceeding. */
 311 gint avahi_server_add_address(
 312     AvahiServer *s,
 313     AvahiEntryGroup *g,
 314     AvahiIfIndex interface,
 315     AvahiProtocol protocol,
 316     AvahiEntryFlags flags,
 317     const gchar *name,
 318     AvahiAddress *a);
 319
 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(
 327     AvahiServer *s,
 328     AvahiEntryGroup *g,
 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" */
 333     const gchar *domain,
 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 */);
 337
 338 /** Mostly identical to avahi_server_add_service(), but takes an va_list for the TXT records. */
 339 gint avahi_server_add_service_va(
 340     AvahiServer *s,
 341     AvahiEntryGroup *g,
 342     AvahiIfIndex interface,
 343     AvahiProtocol protocol,
 344     const gchar *name,
 345     const gchar *type,
 346     const gchar *domain,
 347     const gchar *host,
 348     guint16 port,
 349     va_list va);
 350
 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(
 353     AvahiServer *s,
 354     AvahiEntryGroup *g,
 355     AvahiIfIndex interface,
 356     AvahiProtocol protocol,
 357     const gchar *name,
 358     const gchar *type,
 359     const gchar *domain,
 360     const gchar *host,
 361     guint16 port,
 362     AvahiStringList *strlst);
 363
 364 /** The type of DNS server */
 365 typedef enum {
 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;
 369
 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(
 374     AvahiServer *s,
 375     AvahiEntryGroup *g,
 376     AvahiIfIndex interface,
 377     AvahiProtocol protocol,
 378     const gchar *domain,
 379     AvahiDNSServerType type,
 380     const AvahiAddress *address,
 381     guint16 port /** should be 53 */);
 382
 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(
 387     AvahiServer *s,
 388     AvahiEntryGroup *g,
 389     AvahiIfIndex interface,
 390     AvahiProtocol protocol,
 391     const gchar *domain,
 392     AvahiDNSServerType type,
 393     const gchar *name,
 394     guint16 port /** should be 53 */);
 395
 396 /** Type of callback event when browsing */
 397 typedef enum {
 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 */
 400 } AvahiBrowserEvent;
 401
 402 /** Type of callback event when resolving */
 403 typedef enum {
 404     AVAHI_RESOLVER_FOUND = 0,         /**< RR found, resolving successful */
 405     AVAHI_RESOLVER_TIMEOUT = -1       /**< Noone responded within the timeout, resolving failed */
 406 } AvahiResolverEvent;
 407
 408 /** A browsing object for arbitrary RRs */
 409 typedef struct AvahiRecordBrowser AvahiRecordBrowser;
 410
 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() */ );
 419
 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 */);
 428
 429 /** Free an AvahiRecordBrowser object */
 430 void avahi_record_browser_free(AvahiRecordBrowser *b);
 431
 432 /** A host name to IP adddress resolver object */
 433 typedef struct AvahiHostNameResolver AvahiHostNameResolver;
 434
 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. */
 443     gpointer userdata);
 444
 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(
 447     AvahiServer *server,
 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,
 453     gpointer userdata);
 454
 455 /** Free a AvahiHostNameResolver object */
 456 void avahi_host_name_resolver_free(AvahiHostNameResolver *r);
 457
 458 /** An IP address to host name resolver object ("reverse lookup") */
 459 typedef struct AvahiAddressResolver AvahiAddressResolver;
 460
 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 */
 469     gpointer userdata);
 470
 471 /** Create an AvahiAddressResolver object. See AvahiRecordBrowser for more info on the paramters. */
 472 AvahiAddressResolver *avahi_address_resolver_new(
 473     AvahiServer *server,
 474     AvahiIfIndex interface,
 475     AvahiProtocol protocol,
 476     const AvahiAddress *address,
 477     AvahiAddressResolverCallback calback,
 478     gpointer userdata);
 479
 480 /** Free an AvahiAddressResolver object */
 481 void avahi_address_resolver_free(AvahiAddressResolver *r);
 482
 483 /** The type of domain to browse for */
 484 typedef enum {
 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;
 492
 493 /** A local domain browsing object. May be used to enumerate domains used on the local LAN */
 494 typedef struct AvahiDomainBrowser AvahiDomainBrowser;
 495
 496 /** Callback prototype for AvahiDomainBrowser events */
 497 typedef void (*AvahiDomainBrowserCallback)(
 498     AvahiDomainBrowser *b,
 499     AvahiIfIndex interface,
 500     AvahiProtocol protocol,
 501     AvahiBrowserEvent event,
 502     const gchar *domain,
 503     gpointer userdata);
 504
 505 /** Create a new AvahiDomainBrowser object */
 506 AvahiDomainBrowser *avahi_domain_browser_new(
 507     AvahiServer *server,
 508     AvahiIfIndex interface,
 509     AvahiProtocol protocol,
 510     const gchar *domain,
 511     AvahiDomainBrowserType type,
 512     AvahiDomainBrowserCallback callback,
 513     gpointer userdata);
 514
 515 /** Free an AvahiDomainBrowser object */
 516 void avahi_domain_browser_free(AvahiDomainBrowser *b);
 517
 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;
 520
 521 /** Callback prototype for AvahiServiceTypeBrowser events */
 522 typedef void (*AvahiServiceTypeBrowserCallback)(
 523     AvahiServiceTypeBrowser *b,
 524     AvahiIfIndex interface,
 525     AvahiProtocol protocol,
 526     AvahiBrowserEvent event,
 527     const gchar *type,
 528     const gchar *domain,
 529     gpointer userdata);
 530
 531 /** Create a new AvahiServiceTypeBrowser object. */
 532 AvahiServiceTypeBrowser *avahi_service_type_browser_new(
 533     AvahiServer *server,
 534     AvahiIfIndex interface,
 535     AvahiProtocol protocol,
 536     const gchar *domain,
 537     AvahiServiceTypeBrowserCallback callback,
 538     gpointer userdata);
 539
 540 /** Free an AvahiServiceTypeBrowser object */
 541 void avahi_service_type_browser_free(AvahiServiceTypeBrowser *b);
 542
 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;
 545
 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" */,
 555     gpointer userdata);
 556
 557 /** Create a new AvahiServiceBrowser object. */
 558 AvahiServiceBrowser *avahi_service_browser_new(
 559     AvahiServer *server,
 560     AvahiIfIndex interface,
 561     AvahiProtocol protocol,
 562     const gchar *service_type /** DNS-SD service type, e.g. "_http._tcp" */,
 563     const gchar *domain,
 564     AvahiServiceBrowserCallback callback,
 565     gpointer userdata);
 566
 567 /** Free an AvahiServiceBrowser object */
 568 void avahi_service_browser_free(AvahiServiceBrowser *b);
 569
 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;
 572
 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 */
 581     const gchar *domain,
 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 */
 586     gpointer userdata);
 587
 588 /** Create a new AvahiServiceResolver object */
 589 AvahiServiceResolver *avahi_service_resolver_new(
 590     AvahiServer *server,
 591     AvahiIfIndex interface,
 592     AvahiProtocol protocol,
 593     const gchar *name,
 594     const gchar *type,
 595     const gchar *domain,
 596     AvahiProtocol aprotocol,    /**< Address family of the desired service address. Use AVAHI_PROTO_UNSPEC if you don't care */
 597     AvahiServiceResolverCallback calback,
 598     gpointer userdata);
 599
 600 /** Free an AvahiServiceResolver object */
 601 void avahi_service_resolver_free(AvahiServiceResolver *r);
 602
 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;
 607
 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 */
 617     gpointer userdata);
 618
 619 /** Create a new AvahiDNSServerBrowser object */
 620 AvahiDNSServerBrowser *avahi_dns_server_browser_new(
 621     AvahiServer *server,
 622     AvahiIfIndex interface,
 623     AvahiProtocol protocol,
 624     const gchar *domain,
 625     AvahiDNSServerType type,
 626     AvahiProtocol aprotocol,  /**< Address protocol for the DNS server */
 627     AvahiDNSServerBrowserCallback callback,
 628     gpointer userdata);
 629
 630 /** Free an AvahiDNSServerBrowser object */
 631 void avahi_dns_server_browser_free(AvahiDNSServerBrowser *b);
 632
 633 /** Return a human readable error string for the specified error code */
 634 const gchar *avahi_strerror(gint error);
 635
 636 /** Return the last error code */
 637 gint avahi_server_errno(AvahiServer *s);
 638
 639 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 640 AVAHI_C_DECL_END
 641 #endif
 642
 643 #endif