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 /** \file core.h The Avahi Multicast DNS and DNS Service Discovery implementation. */
  26
  27
  28 #include <avahi-common/cdecl.h>
  29
  30 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  31 AVAHI_C_DECL_BEGIN
  32 #endif
  33
  34 /** An mDNS responder object */
  35 typedef struct AvahiServer AvahiServer;
  36
  37 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  38 AVAHI_C_DECL_END
  39 #endif
  40
  41 #include <avahi-core/rr.h>
  42 #include <avahi-common/address.h>
  43 #include <avahi-common/defs.h>
  44 #include <avahi-common/watch.h>
  45
  46 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  47 AVAHI_C_DECL_BEGIN
  48 #endif
  49
  50 /** Maximum number of defined DNS servers for wide area DNS */
  51 #define AVAHI_MAX_WIDE_AREA_SERVERS 4
  52
  53 /** Flags for server entries */
  54 typedef enum {
  55     AVAHI_ENTRY_NULL = 0,          /**< No special flags */
  56     AVAHI_ENTRY_UNIQUE = 1,        /**< The RRset is intended to be unique */
  57     AVAHI_ENTRY_NOPROBE = 2,       /**< Though the RRset is intended to be unique no probes shall be sent */
  58     AVAHI_ENTRY_NOANNOUNCE = 4,    /**< Do not announce this RR to other hosts */
  59     AVAHI_ENTRY_ALLOWMUTIPLE = 8   /**< Allow multiple local records of this type, even if they are intended to be unique */
  60 } AvahiEntryFlags;
  61
  62 /** Prototype for callback functions which are called whenever the state of an AvahiServer object changes */
  63 typedef void (*AvahiServerCallback) (AvahiServer *s, AvahiServerState state, void* userdata);
  64
  65 /** Stores configuration options for a server instance */
  66 typedef struct AvahiServerConfig {
  67     char *host_name;                  /**< Default host name. If left empty defaults to the result of gethostname(2) of the libc */
  68     char *domain_name;                /**< Default domain name. If left empty defaults to .local */
  69     int use_ipv4;                     /**< Enable IPv4 support */
  70     int use_ipv6;                     /**< Enable IPv6 support */
  71     int publish_hinfo;                /**< Register a HINFO record for the host containing the local OS and CPU type */
  72     int publish_addresses;            /**< Register A, AAAA and PTR records for all local IP addresses */
  73     int publish_workstation;          /**< Register a _workstation._tcp service */
  74     int publish_domain;               /**< Announce the local domain for browsing */
  75     int 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. */
  76     int 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. */
  77     int enable_reflector;             /**< Reflect incoming mDNS traffic to all local networks. This allows mDNS based network browsing beyond ethernet borders */
  78     int reflect_ipv;                  /**< if enable_reflector is 1, enable/disable reflecting between IPv4 and IPv6 */
  79     int add_service_cookie;           /**< Add magic service cookie to all locally generated records implicitly */
  80     int enable_wide_area;             /**< Enable wide area support */
  81     AvahiAddress wide_area_servers[AVAHI_MAX_WIDE_AREA_SERVERS]; /** Unicast DNS server to use for wide area lookup */
  82     unsigned n_wide_area_servers;     /**< Number of servers in wide_area_servers[] */
  83     int disallow_other_stacks;        /**< Make sure that only one mDNS responder is run at the same time on the local machine. If this is enable Avahi will not set SO_REUSADDR on its sockets, effectively preventing other stacks from running on the local machine */
  84 } AvahiServerConfig;
  85
  86 /** Allocate a new mDNS responder object. */
  87 AvahiServer *avahi_server_new(
  88     const AvahiPoll *api,          /**< The main loop adapter */
  89     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. */
  90     AvahiServerCallback callback,  /**< A callback which is called whenever the state of the server changes */
  91     void* userdata,                /**< An opaque pointer which is passed to the callback function */
  92     int *error);
  93
  94 /** Free an mDNS responder object */
  95 void avahi_server_free(AvahiServer* s);
  96
  97 /** Fill in default values for a server configuration structure. If you
  98  * make use of an AvahiServerConfig structure be sure to initialize
  99  * it with this function for the sake of upwards library
 100  * compatibility. This call may allocate strings on the heap. To
 101  * release this memory make sure to call
 102  * avahi_server_config_done(). If you want to replace any strings in
 103  * the structure be sure to free the strings filled in by this
 104  * function with avahi_free() first and allocate the replacements with
 105  * g_malloc() (or g_strdup()).*/
 106 AvahiServerConfig* avahi_server_config_init(
 107    AvahiServerConfig *c /**< A structure which shall be filled in */ );
 108
 109 /** Make a deep copy of the configuration structure *c to *ret. */
 110 AvahiServerConfig* avahi_server_config_copy(
 111     AvahiServerConfig *ret /**< destination */,
 112     const AvahiServerConfig *c /**< source */);
 113
 114 /** Free the data in a server configuration structure. */
 115 void avahi_server_config_free(AvahiServerConfig *c);
 116
 117 /** Return the currently chosen domain name of the server object. The
 118  * return value points to an internally allocated string. Be sure to
 119  * make a copy of the string before calling any other library
 120  * functions. */
 121 const char* avahi_server_get_domain_name(AvahiServer *s);
 122
 123 /** Return the currently chosen host name. The return value points to a internally allocated string. */
 124 const char* avahi_server_get_host_name(AvahiServer *s);
 125
 126 /** Return the currently chosen host name as a FQDN ("fully qualified
 127  * domain name", i.e. the concatenation of the host and domain
 128  * name). The return value points to a internally allocated string. */
 129 const char* avahi_server_get_host_name_fqdn(AvahiServer *s);
 130
 131 /** Change the host name of a running mDNS responder. This will drop
 132 all automicatilly generated RRs and readd them with the new
 133 name. Since the responder has to probe for the new RRs this function
 134 takes some time to take effect altough it returns immediately. This
 135 function is intended to be called when a host name conflict is
 136 reported using AvahiServerCallback. The caller should readd all user
 137 defined RRs too since they otherwise continue to point to the outdated
 138 host name..*/
 139 int avahi_server_set_host_name(AvahiServer *s, const char *host_name);
 140
 141 /** Change the domain name of a running mDNS responder. The same rules
 142  * as with avahi_server_set_host_name() apply. */
 143 int avahi_server_set_domain_name(AvahiServer *s, const char *domain_name);
 144
 145 /** Return the opaque user data pointer attached to a server object */
 146 void* avahi_server_get_data(AvahiServer *s);
 147
 148 /** Change the opaque user data pointer attached to a server object */
 149 void avahi_server_set_data(AvahiServer *s, void* userdata);
 150
 151 /** Return the current state of the server object */
 152 AvahiServerState avahi_server_get_state(AvahiServer *s);
 153
 154 /** Callback prototype for avahi_server_dump() */
 155 typedef void (*AvahiDumpCallback)(const char *text, void* userdata);
 156
 157 /** Dump the current server status by calling "callback" for each line.  */
 158 int avahi_server_dump(AvahiServer *s, AvahiDumpCallback callback, void* userdata);
 159
 160 /** Return the last error code */
 161 int avahi_server_errno(AvahiServer *s);
 162
 163 /** Return the local service cookie */
 164 uint32_t avahi_server_get_local_service_cookie(AvahiServer *s);
 165
 166 /** Return 1 if there is a local service with the specified credentials registeresd. Return 0 if not, negative on failure */
 167 int avahi_server_is_service_local(AvahiServer *s, AvahiIfIndex, AvahiProtocol protocol, const char *name, const char *type,  const char*domain);
 168
 169 /** Set the wide area DNS servers */
 170 int avahi_server_set_wide_area_servers(AvahiServer *s, const AvahiAddress *a, unsigned n);
 171
 172 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 173 AVAHI_C_DECL_END
 174 #endif
 175
 176 #endif