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

   1 #ifndef foointernalhfoo
   2 #define foointernalhfoo
   3
   4 /***
   5   This file is part of avahi.
   6
   7   avahi is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as
   9   published by the Free Software Foundation; either version 2.1 of the
  10   License, or (at your option) any later version.
  11
  12   avahi is distributed in the hope that it will be useful, but WITHOUT
  13   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
  15   Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public
  18   License along with avahi; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 /** A locally registered DNS resource record */
  24 typedef struct AvahiEntry AvahiEntry;
  25
  26 #include <avahi-common/llist.h>
  27 #include <avahi-common/watch.h>
  28
  29 #include "core.h"
  30 #include "iface.h"
  31 #include "prioq.h"
  32 #include "timeeventq.h"
  33 #include "announce.h"
  34 #include "browse.h"
  35 #include "dns.h"
  36 #include "rrlist.h"
  37 #include "hashmap.h"
  38 #include "wide-area.h"
  39 #include "multicast-lookup.h"
  40 #include "dns-srv-rr.h"
  41
  42 #define AVAHI_LEGACY_UNICAST_REFLECT_SLOTS_MAX 100
  43
  44 #define AVAHI_FLAGS_VALID(flags, max) (!((flags) & ~(max)))
  45
  46 #define AVAHI_RR_HOLDOFF_MSEC 1000
  47 #define AVAHI_RR_HOLDOFF_MSEC_RATE_LIMIT 20000
  48 #define AVAHI_RR_RATE_LIMIT_COUNT 15
  49
  50 typedef struct AvahiLegacyUnicastReflectSlot AvahiLegacyUnicastReflectSlot;
  51
  52 struct AvahiLegacyUnicastReflectSlot {
  53     AvahiServer *server;
  54
  55     uint16_t id, original_id;
  56     AvahiAddress address;
  57     uint16_t port;
  58     int interface;
  59     struct timeval elapse_time;
  60     AvahiTimeEvent *time_event;
  61 };
  62
  63 struct AvahiEntry {
  64     AvahiServer *server;
  65     AvahiSEntryGroup *group;
  66
  67     int dead;
  68
  69     AvahiPublishFlags flags;
  70     AvahiRecord *record;
  71     AvahiIfIndex interface;
  72     AvahiProtocol protocol;
  73
  74     AVAHI_LLIST_FIELDS(AvahiEntry, entries);
  75     AVAHI_LLIST_FIELDS(AvahiEntry, by_key);
  76     AVAHI_LLIST_FIELDS(AvahiEntry, by_group);
  77
  78     AVAHI_LLIST_HEAD(AvahiAnnouncer, announcers);
  79 };
  80
  81 struct AvahiSEntryGroup {
  82     AvahiServer *server;
  83     int dead;
  84
  85     AvahiEntryGroupState state;
  86     void* userdata;
  87     AvahiSEntryGroupCallback callback;
  88
  89     unsigned n_probing;
  90
  91     unsigned n_register_try;
  92     struct timeval register_time;
  93     AvahiTimeEvent *register_time_event;
  94
  95     struct timeval established_at;
  96
  97     AVAHI_LLIST_FIELDS(AvahiSEntryGroup, groups);
  98     AVAHI_LLIST_HEAD(AvahiEntry, entries);
  99 };
 100
 101 struct AvahiServer {
 102     const AvahiPoll *poll_api;
 103
 104     AvahiInterfaceMonitor *monitor;
 105     AvahiServerConfig config;
 106
 107     AVAHI_LLIST_HEAD(AvahiEntry, entries);
 108     AvahiHashmap *entries_by_key;
 109
 110     AVAHI_LLIST_HEAD(AvahiSEntryGroup, groups);
 111
 112     AVAHI_LLIST_HEAD(AvahiSRecordBrowser, record_browsers);
 113     AvahiHashmap *record_browser_hashmap;
 114     AVAHI_LLIST_HEAD(AvahiSHostNameResolver, host_name_resolvers);
 115     AVAHI_LLIST_HEAD(AvahiSAddressResolver, address_resolvers);
 116     AVAHI_LLIST_HEAD(AvahiSDomainBrowser, domain_browsers);
 117     AVAHI_LLIST_HEAD(AvahiSServiceTypeBrowser, service_type_browsers);
 118     AVAHI_LLIST_HEAD(AvahiSServiceBrowser, service_browsers);
 119     AVAHI_LLIST_HEAD(AvahiSServiceResolver, service_resolvers);
 120     AVAHI_LLIST_HEAD(AvahiSDNSServerBrowser, dns_server_browsers);
 121
 122     int need_entry_cleanup, need_group_cleanup, need_browser_cleanup;
 123
 124     AvahiTimeEventQueue *time_event_queue;
 125
 126     char *host_name, *host_name_fqdn, *domain_name;
 127
 128     int fd_ipv4, fd_ipv6,
 129         /* The following two sockets two are used for reflection only */
 130         fd_legacy_unicast_ipv4, fd_legacy_unicast_ipv6;
 131
 132     AvahiWatch *watch_ipv4, *watch_ipv6,
 133         *watch_legacy_unicast_ipv4, *watch_legacy_unicast_ipv6;
 134
 135     AvahiServerState state;
 136     AvahiServerCallback callback;
 137     void* userdata;
 138
 139     AvahiSEntryGroup *hinfo_entry_group;
 140     AvahiSEntryGroup *browse_domain_entry_group;
 141     unsigned n_host_rr_pending;
 142
 143     /* Used for assembling responses */
 144     AvahiRecordList *record_list;
 145
 146     /* Used for reflection of legacy unicast packets */
 147     AvahiLegacyUnicastReflectSlot **legacy_unicast_reflect_slots;
 148     uint16_t legacy_unicast_reflect_id;
 149
 150     /* The last error code */
 151     int error;
 152
 153     /* The local service cookie */
 154     uint32_t local_service_cookie;
 155
 156     AvahiMulticastLookupEngine *multicast_lookup_engine;
 157     AvahiWideAreaLookupEngine *wide_area_lookup_engine;
 158 };
 159
 160 void avahi_entry_free(AvahiServer*s, AvahiEntry *e);
 161 void avahi_entry_group_free(AvahiServer *s, AvahiSEntryGroup *g);
 162
 163 void avahi_cleanup_dead_entries(AvahiServer *s);
 164
 165 void avahi_server_prepare_response(AvahiServer *s, AvahiInterface *i, AvahiEntry *e, int unicast_response, int auxiliary);
 166 void avahi_server_prepare_matching_responses(AvahiServer *s, AvahiInterface *i, AvahiKey *k, int unicast_response);
 167 void avahi_server_generate_response(AvahiServer *s, AvahiInterface *i, AvahiDnsPacket *p, const AvahiAddress *a, uint16_t port, int legacy_unicast, int is_probe);
 168
 169 void avahi_s_entry_group_change_state(AvahiSEntryGroup *g, AvahiEntryGroupState state);
 170
 171 int avahi_entry_is_commited(AvahiEntry *e);
 172
 173 void avahi_server_enumerate_aux_records(AvahiServer *s, AvahiInterface *i, AvahiRecord *r, void (*callback)(AvahiServer *s, AvahiRecord *r, int flush_cache, void* userdata), void* userdata);
 174
 175 void avahi_host_rr_entry_group_callback(AvahiServer *s, AvahiSEntryGroup *g, AvahiEntryGroupState state, void *userdata);
 176
 177 void avahi_server_decrease_host_rr_pending(AvahiServer *s);
 178
 179 int avahi_server_set_errno(AvahiServer *s, int error);
 180
 181 int avahi_server_is_service_local(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, const char *name);
 182 int avahi_server_is_record_local(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, AvahiRecord *record);
 183
 184 int avahi_server_add_ptr(
 185     AvahiServer *s,
 186     AvahiSEntryGroup *g,
 187     AvahiIfIndex interface,
 188     AvahiProtocol protocol,
 189     AvahiPublishFlags flags,
 190     uint32_t ttl,
 191     const char *name,
 192     const char *dest);
 193
 194 #define AVAHI_CHECK_VALIDITY(server, expression, error) { \
 195         if (!(expression)) \
 196             return avahi_server_set_errno((server), (error)); \
 197 }
 198
 199 #define AVAHI_CHECK_VALIDITY_RETURN_NULL(server, expression, error) { \
 200         if (!(expression)) { \
 201             avahi_server_set_errno((server), (error)); \
 202             return NULL; \
 203         } \
 204 }
 205
 206 #define AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(server, expression, error) {\
 207     if (!(expression)) { \
 208         ret = avahi_server_set_errno((server), (error)); \
 209         goto fail; \
 210     } \
 211 }
 212
 213 #define AVAHI_ASSERT_TRUE(expression) { \
 214     int __tmp = !!(expression); \
 215     assert(__tmp); \
 216 }
 217
 218 #define AVAHI_ASSERT_SUCCESS(expression) { \
 219     int __tmp = (expression); \
 220     assert(__tmp == 0); \
 221 }
 222
 223 #endif