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