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 <stdio.h>
  26 #include <glib.h>
  27
  28 /** An mDNS responder object */
  29 typedef struct AvahiServer AvahiServer;
  30
  31 /** A locally registered DNS resource record */
  32 typedef struct AvahiEntry AvahiEntry;
  33
  34 /** A group of locally registered DNS RRs */
  35 typedef struct AvahiEntryGroup AvahiEntryGroup;
  36
  37 #include <avahi-core/address.h>
  38 #include <avahi-core/rr.h>
  39
  40 /** States of a server object */
  41 typedef enum {
  42     AVAHI_SERVER_INVALID = -1,     /**< Invalid state (initial) */
  43     AVAHI_SERVER_REGISTERING = 0,  /**< Host RRs are being registered */
  44     AVAHI_SERVER_RUNNING,          /**< All host RRs have been established */
  45     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() */
  46     AVAHI_SERVER_SLEEPING          /**< The host or domain name has changed and the server waits for old entries to be expired */
  47 } AvahiServerState;
  48
  49 /** Flags for server entries */
  50 typedef enum {
  51     AVAHI_ENTRY_NULL = 0,          /**< No special flags */
  52     AVAHI_ENTRY_UNIQUE = 1,        /**< The RRset is intended to be unique */
  53     AVAHI_ENTRY_NOPROBE = 2,       /**< Though the RRset is intended to be unique no probes shall be sent */
  54     AVAHI_ENTRY_NOANNOUNCE = 4     /**< Do not announce this RR to other hosts */
  55 } AvahiEntryFlags;
  56
  57 /** States of an entry group object */
  58 typedef enum {
  59     AVAHI_ENTRY_GROUP_UNCOMMITED = -1,   /**< The group has not yet been commited, the user must still call avahi_entry_group_commit() */
  60     AVAHI_ENTRY_GROUP_REGISTERING = 0,   /**< The entries of the group are currently being registered */
  61     AVAHI_ENTRY_GROUP_ESTABLISHED,       /**< The entries have successfully been established */
  62     AVAHI_ENTRY_GROUP_COLLISION          /**< A name collision for one of the entries in the group has been detected, the entries have been withdrawn */
  63 } AvahiEntryGroupState;
  64
  65 /** Prototype for callback functions which are called whenever the state of an AvahiServer object changes */
  66 typedef void (*AvahiServerCallback) (AvahiServer *s, AvahiServerState state, gpointer userdata);
  67
  68 /** Prototype for callback functions which are called whenever the state of an AvahiEntryGroup object changes */
  69 typedef void (*AvahiEntryGroupCallback) (AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, gpointer userdata);
  70
  71 /** Stores configuration options for a server instance */
  72 typedef struct AvahiServerConfig {
  73     gchar *host_name;                      /**< Default host name. If left empty defaults to the result of gethostname(2) of the libc */
  74     gchar *domain_name;                    /**< Default domain name. If left empty defaults to .local */
  75     gboolean use_ipv4;                     /**< Enable IPv4 support */
  76     gboolean use_ipv6;                     /**< Enable IPv6 support */
  77     gboolean register_hinfo;               /**< Register a HINFO record for the host containing the local OS and CPU type */
  78     gboolean register_addresses;           /**< Register A, AAAA and PTR records for all local IP addresses */
  79     gboolean check_response_ttl;           /**< If enabled the server ignores all incoming responses with IP TTL != 255 */
  80     gboolean announce_domain;              /**< Announce the local domain for browsing */
  81     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. */
  82     gboolean enable_reflector;             /**< Reflect incoming mDNS traffic to all local networks. This allows mDNS based network browsing beyond ethernet borders */
  83 } AvahiServerConfig;
  84
  85 /** Allocate a new mDNS responder object. */
  86 AvahiServer *avahi_server_new(
  87     GMainContext *c,               /**< The GLIB main loop context to attach to */
  88     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. */
  89     AvahiServerCallback callback,  /**< A callback which is called whenever the state of the server changes */
  90     gpointer userdata              /**< An opaque pointer which is passed to the callback function */);
  91
  92 /** Free an mDNS responder object */
  93 void avahi_server_free(AvahiServer* s);
  94
  95 /** Fill in default values for a server configuration structure. If you
  96  * make use of an AvahiServerConfig structure be sure to initialize
  97  * it with this function for the sake of upwards library
  98  * compatibility. This call may allocate strings on the heap. To
  99  * release this memory make sure to call
 100  * avahi_server_config_done(). If you want to replace any strings in
 101  * the structure be sure to free the strings filled in by this
 102  * function with g_free() first and allocate the replacements with
 103  * g_malloc() (or g_strdup()).*/
 104 AvahiServerConfig* avahi_server_config_init(
 105    AvahiServerConfig *c /**< A structure which shall be filled in */ );
 106
 107 /** Make a deep copy of the configuration structure *c to *ret. */
 108 AvahiServerConfig* avahi_server_config_copy(
 109     AvahiServerConfig *ret /**< destination */,
 110     const AvahiServerConfig *c /**< source */);
 111
 112 /** Free the data in a server configuration structure. */
 113 void avahi_server_config_free(AvahiServerConfig *c);
 114
 115 /** Return the currently chosen domain name of the server object. The
 116  * return value points to an internally allocated string. Be sure to
 117  * make a copy of the string before calling any other library
 118  * functions. */
 119 const gchar* avahi_server_get_domain_name(AvahiServer *s);
 120
 121 /** Return the currently chosen host name. The return value points to a internally allocated string. */
 122 const gchar* avahi_server_get_host_name(AvahiServer *s);
 123
 124 /** Return the currently chosen host name as a FQDN ("fully qualified
 125  * domain name", i.e. the concatenation of the host and domain
 126  * name). The return value points to a internally allocated string. */
 127 const gchar* avahi_server_get_host_name_fqdn(AvahiServer *s);
 128
 129 void avahi_server_set_host_name(AvahiServer *s, const gchar *host_name);
 130 void avahi_server_set_domain_name(AvahiServer *s, const gchar *domain_name);
 131
 132 gpointer avahi_server_get_data(AvahiServer *s);
 133 void avahi_server_set_data(AvahiServer *s, gpointer userdata);
 134
 135 AvahiServerState avahi_server_get_state(AvahiServer *s);
 136
 137 const AvahiRecord *avahi_server_iterate(AvahiServer *s, AvahiEntryGroup *g, void **state);
 138 void avahi_server_dump(AvahiServer *s, FILE *f);
 139
 140 AvahiEntryGroup *avahi_entry_group_new(AvahiServer *s, AvahiEntryGroupCallback callback, gpointer userdata);
 141 void avahi_entry_group_free(AvahiEntryGroup *g);
 142 void avahi_entry_group_commit(AvahiEntryGroup *g);
 143 AvahiEntryGroupState avahi_entry_group_get_state(AvahiEntryGroup *g);
 144 void avahi_entry_group_set_data(AvahiEntryGroup *g, gpointer userdata);
 145 gpointer avahi_entry_group_get_data(AvahiEntryGroup *g);
 146
 147 void avahi_server_add(
 148     AvahiServer *s,
 149     AvahiEntryGroup *g,
 150     gint interface,
 151     guchar protocol,
 152     AvahiEntryFlags flags,
 153     AvahiRecord *r);
 154
 155 void avahi_server_add_ptr(
 156     AvahiServer *s,
 157     AvahiEntryGroup *g,
 158     gint interface,
 159     guchar protocol,
 160     AvahiEntryFlags flags,
 161     const gchar *name,
 162     const gchar *dest);
 163
 164 void avahi_server_add_address(
 165     AvahiServer *s,
 166     AvahiEntryGroup *g,
 167     gint interface,
 168     guchar protocol,
 169     AvahiEntryFlags flags,
 170     const gchar *name,
 171     AvahiAddress *a);
 172
 173 void avahi_server_add_text(
 174     AvahiServer *s,
 175     AvahiEntryGroup *g,
 176     gint interface,
 177     guchar protocol,
 178     AvahiEntryFlags flags,
 179     const gchar *name,
 180     ... /* text records, terminated by NULL */);
 181
 182 void avahi_server_add_text_va(
 183     AvahiServer *s,
 184     AvahiEntryGroup *g,
 185     gint interface,
 186     guchar protocol,
 187     AvahiEntryFlags flags,
 188     const gchar *name,
 189     va_list va);
 190
 191 void avahi_server_add_text_strlst(
 192     AvahiServer *s,
 193     AvahiEntryGroup *g,
 194     gint interface,
 195     guchar protocol,
 196     AvahiEntryFlags flags,
 197     const gchar *name,
 198     AvahiStringList *strlst);
 199
 200 void avahi_server_add_service(
 201     AvahiServer *s,
 202     AvahiEntryGroup *g,
 203     gint interface,
 204     guchar protocol,
 205     const gchar *type,
 206     const gchar *name,
 207     const gchar *domain,
 208     const gchar *host,
 209     guint16 port,
 210     ...  /* text records, terminated by NULL */);
 211
 212 void avahi_server_add_service_va(
 213     AvahiServer *s,
 214     AvahiEntryGroup *g,
 215     gint interface,
 216     guchar protocol,
 217     const gchar *type,
 218     const gchar *name,
 219     const gchar *domain,
 220     const gchar *host,
 221     guint16 port,
 222     va_list va);
 223
 224 void avahi_server_add_service_strlst(
 225     AvahiServer *s,
 226     AvahiEntryGroup *g,
 227     gint interface,
 228     guchar protocol,
 229     const gchar *type,
 230     const gchar *name,
 231     const gchar *domain,
 232     const gchar *host,
 233     guint16 port,
 234     AvahiStringList *strlst);
 235
 236 typedef enum {
 237     AVAHI_BROWSER_NEW = 0,
 238     AVAHI_BROWSER_REMOVE = -1
 239 } AvahiBrowserEvent;
 240
 241 typedef enum {
 242     AVAHI_RESOLVER_FOUND = 0,
 243     AVAHI_RESOLVER_TIMEOUT = -1
 244 } AvahiResolverEvent;
 245
 246
 247 typedef struct AvahiRecordBrowser AvahiRecordBrowser;
 248 typedef void (*AvahiRecordBrowserCallback)(AvahiRecordBrowser *b, gint interface, guchar protocol, AvahiBrowserEvent event, AvahiRecord *record, gpointer userdata);
 249 AvahiRecordBrowser *avahi_record_browser_new(AvahiServer *server, gint interface, guchar protocol, AvahiKey *key, AvahiRecordBrowserCallback callback, gpointer userdata);
 250 void avahi_record_browser_free(AvahiRecordBrowser *b);
 251
 252 typedef struct AvahiHostNameResolver AvahiHostNameResolver;
 253 typedef void (*AvahiHostNameResolverCallback)(AvahiHostNameResolver *r, gint interface, guchar protocol, AvahiResolverEvent event, const gchar *host_name, const AvahiAddress *a, gpointer userdata);
 254 AvahiHostNameResolver *avahi_host_name_resolver_new(AvahiServer *server, gint interface, guchar protocol, const gchar *host_name, guchar aprotocol, AvahiHostNameResolverCallback calback, gpointer userdata);
 255 void avahi_host_name_resolver_free(AvahiHostNameResolver *r);
 256
 257 typedef struct AvahiAddressResolver AvahiAddressResolver;
 258 typedef void (*AvahiAddressResolverCallback)(AvahiAddressResolver *r, gint interface, guchar protocol, AvahiResolverEvent event, const AvahiAddress *a, const gchar *host_name, gpointer userdata);
 259 AvahiAddressResolver *avahi_address_resolver_new(AvahiServer *server, gint interface, guchar protocol, const AvahiAddress *address, AvahiAddressResolverCallback calback, gpointer userdata);
 260 void avahi_address_resolver_free(AvahiAddressResolver *r);
 261
 262 typedef enum {
 263     AVAHI_DOMAIN_BROWSER_REGISTER,
 264     AVAHI_DOMAIN_BROWSER_REGISTER_DEFAULT,
 265     AVAHI_DOMAIN_BROWSER_BROWSE,
 266     AVAHI_DOMAIN_BROWSER_BROWSE_DEFAULT
 267 } AvahiDomainBrowserType;
 268
 269 typedef struct AvahiDomainBrowser AvahiDomainBrowser;
 270 typedef void (*AvahiDomainBrowserCallback)(AvahiDomainBrowser *b, gint interface, guchar protocol, AvahiBrowserEvent event, const gchar *domain, gpointer userdata);
 271 AvahiDomainBrowser *avahi_domain_browser_new(AvahiServer *server, gint interface, guchar protocol, const gchar *domain, AvahiDomainBrowserType type, AvahiDomainBrowserCallback callback, gpointer userdata);
 272 void avahi_domain_browser_free(AvahiDomainBrowser *b);
 273
 274 typedef struct AvahiServiceTypeBrowser AvahiServiceTypeBrowser;
 275 typedef void (*AvahiServiceTypeBrowserCallback)(AvahiServiceTypeBrowser *b, gint interface, guchar protocol, AvahiBrowserEvent event, const gchar *type, const gchar *domain, gpointer userdata);
 276 AvahiServiceTypeBrowser *avahi_service_type_browser_new(AvahiServer *server, gint interface, guchar protocol, const gchar *domain, AvahiServiceTypeBrowserCallback callback, gpointer userdata);
 277 void avahi_service_type_browser_free(AvahiServiceTypeBrowser *b);
 278
 279 typedef struct AvahiServiceBrowser AvahiServiceBrowser;
 280 typedef void (*AvahiServiceBrowserCallback)(AvahiServiceBrowser *b, gint interface, guchar protocol, AvahiBrowserEvent event, const gchar *name, const gchar *type, const gchar *domain, gpointer userdata);
 281 AvahiServiceBrowser *avahi_service_browser_new(AvahiServer *server, gint interface, guchar protocol, const gchar *service_type, const gchar *domain, AvahiServiceBrowserCallback callback, gpointer userdata);
 282 void avahi_service_browser_free(AvahiServiceBrowser *b);
 283
 284 typedef struct AvahiServiceResolver AvahiServiceResolver;
 285 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);
 286 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);
 287 void avahi_service_resolver_free(AvahiServiceResolver *r);
 288
 289 #endif