git.meshlink.io Git - catta/blob - avahi-core/browse-dns-server.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of avahi.
   5
   6   avahi is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as
   8   published by the Free Software Foundation; either version 2.1 of the
   9   License, or (at your option) any later version.
  10
  11   avahi is distributed in the hope that it will be useful, but WITHOUT
  12   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
  14   Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public
  17   License along with avahi; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <string.h>
  27
  28 #include <avahi-common/domain.h>
  29 #include <avahi-common/malloc.h>
  30 #include <avahi-common/error.h>
  31
  32 #include "browse.h"
  33 #include "log.h"
  34 #include "rr.h"
  35
  36 typedef struct AvahiDNSServerInfo AvahiDNSServerInfo;
  37
  38 struct AvahiDNSServerInfo {
  39     AvahiSDNSServerBrowser *browser;
  40
  41     AvahiIfIndex interface;
  42     AvahiProtocol protocol;
  43     AvahiRecord *srv_record;
  44     AvahiSHostNameResolver *host_name_resolver;
  45     AvahiAddress address;
  46     AvahiLookupResultFlags flags;
  47
  48     AVAHI_LLIST_FIELDS(AvahiDNSServerInfo, info);
  49 };
  50
  51 struct AvahiSDNSServerBrowser {
  52     AvahiServer *server;
  53     char *domain_name;
  54
  55     AvahiSRecordBrowser *record_browser;
  56     AvahiSDNSServerBrowserCallback callback;
  57     void* userdata;
  58     AvahiProtocol aprotocol;
  59     AvahiLookupFlags user_flags;
  60
  61     unsigned n_info;
  62
  63     AVAHI_LLIST_FIELDS(AvahiSDNSServerBrowser, browser);
  64     AVAHI_LLIST_HEAD(AvahiDNSServerInfo, info);
  65 };
  66
  67 static AvahiDNSServerInfo* get_server_info(AvahiSDNSServerBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiRecord *r) {
  68     AvahiDNSServerInfo *i;
  69
  70     assert(b);
  71     assert(r);
  72
  73     for (i = b->info; i; i = i->info_next)
  74         if (i->interface == interface &&
  75             i->protocol == protocol &&
  76             avahi_record_equal_no_ttl(r, i->srv_record))
  77             return i;
  78
  79     return NULL;
  80 }
  81
  82 static void server_info_free(AvahiSDNSServerBrowser *b, AvahiDNSServerInfo *i) {
  83     assert(b);
  84     assert(i);
  85
  86     avahi_record_unref(i->srv_record);
  87     if (i->host_name_resolver)
  88         avahi_s_host_name_resolver_free(i->host_name_resolver);
  89
  90     AVAHI_LLIST_REMOVE(AvahiDNSServerInfo, info, b->info, i);
  91
  92     assert(b->n_info >= 1);
  93     b->n_info--;
  94
  95     avahi_free(i);
  96 }
  97
  98 static void host_name_resolver_callback(
  99     AvahiSHostNameResolver *r,
 100     AvahiIfIndex interface,
 101     AvahiProtocol protocol,
 102     AvahiResolverEvent event,
 103     const char *host_name,
 104     const AvahiAddress *a,
 105     AvahiLookupResultFlags flags,
 106     void* userdata) {
 107
 108     AvahiDNSServerInfo *i = userdata;
 109
 110     assert(r);
 111     assert(host_name);
 112     assert(i);
 113
 114     switch (event) {
 115         case AVAHI_RESOLVER_FOUND: {
 116             i->address = *a;
 117
 118             i->browser->callback(
 119                 i->browser,
 120                 i->interface,
 121                 i->protocol,
 122                 AVAHI_BROWSER_NEW,
 123                 i->srv_record->data.srv.name,
 124                 &i->address,
 125                 i->srv_record->data.srv.port,
 126                 i->flags | flags,
 127                 i->browser->userdata);
 128
 129             break;
 130         }
 131
 132         case AVAHI_RESOLVER_NOT_FOUND:
 133         case AVAHI_RESOLVER_FAILURE:
 134         case AVAHI_RESOLVER_TIMEOUT:
 135             /* Ignore */
 136             break;
 137     }
 138
 139     avahi_s_host_name_resolver_free(i->host_name_resolver);
 140     i->host_name_resolver = NULL;
 141 }
 142
 143 static void record_browser_callback(
 144     AvahiSRecordBrowser*rr,
 145     AvahiIfIndex interface,
 146     AvahiProtocol protocol,
 147     AvahiBrowserEvent event,
 148     AvahiRecord *record,
 149     AvahiLookupResultFlags flags,
 150     void* userdata) {
 151
 152     AvahiSDNSServerBrowser *b = userdata;
 153
 154     assert(rr);
 155     assert(b);
 156
 157
 158     switch (event) {
 159         case AVAHI_BROWSER_NEW: {
 160             AvahiDNSServerInfo *i;
 161
 162             assert(record);
 163             assert(record->key->type == AVAHI_DNS_TYPE_SRV);
 164
 165             if (get_server_info(b, interface, protocol, record))
 166                 return;
 167
 168             if (b->n_info >= 10)
 169                 return;
 170
 171             if (!(i = avahi_new(AvahiDNSServerInfo, 1)))
 172                 return; /* OOM */
 173
 174             i->browser = b;
 175             i->interface = interface;
 176             i->protocol = protocol;
 177             i->srv_record = avahi_record_ref(record);
 178             i->host_name_resolver = avahi_s_host_name_resolver_new(
 179                 b->server,
 180                 interface, protocol,
 181                 record->data.srv.name,
 182                 b->aprotocol,
 183                 b->user_flags,
 184                 host_name_resolver_callback, i);
 185             i->flags = flags;
 186
 187             AVAHI_LLIST_PREPEND(AvahiDNSServerInfo, info, b->info, i);
 188
 189             b->n_info++;
 190             break;
 191         }
 192
 193         case AVAHI_BROWSER_REMOVE: {
 194             AvahiDNSServerInfo *i;
 195
 196             assert(record);
 197             assert(record->key->type == AVAHI_DNS_TYPE_SRV);
 198
 199             if (!(i = get_server_info(b, interface, protocol, record)))
 200                 return;
 201
 202             if (!i->host_name_resolver)
 203                 b->callback(
 204                     b,
 205                     interface,
 206                     protocol,
 207                     event,
 208                     i->srv_record->data.srv.name,
 209                     &i->address,
 210                     i->srv_record->data.srv.port,
 211                     i->flags | flags,
 212                     b->userdata);
 213
 214             server_info_free(b, i);
 215             break;
 216         }
 217
 218         case AVAHI_BROWSER_FAILURE:
 219         case AVAHI_BROWSER_NOT_FOUND:
 220         case AVAHI_BROWSER_ALL_FOR_NOW:
 221         case AVAHI_BROWSER_CACHE_EXHAUSTED:
 222
 223             b->callback(
 224                 b,
 225                 interface,
 226                 protocol,
 227                 event,
 228                 NULL,
 229                 NULL,
 230                 0,
 231                 flags,
 232                 b->userdata);
 233
 234             break;
 235     }
 236 }
 237
 238 AvahiSDNSServerBrowser *avahi_s_dns_server_browser_new(
 239     AvahiServer *server,
 240     AvahiIfIndex interface,
 241     AvahiProtocol protocol,
 242     const char *domain,
 243     AvahiDNSServerType type,
 244     AvahiProtocol aprotocol,
 245     AvahiLookupFlags flags,
 246     AvahiSDNSServerBrowserCallback callback,
 247     void* userdata) {
 248
 249     AvahiSDNSServerBrowser *b;
 250     AvahiKey *k;
 251     char *n = NULL;
 252
 253     assert(server);
 254     assert(callback);
 255     assert(type == AVAHI_DNS_SERVER_RESOLVE || type == AVAHI_DNS_SERVER_UPDATE);
 256
 257     if (domain && !avahi_is_valid_domain_name(domain)) {
 258         avahi_server_set_errno(server, AVAHI_ERR_INVALID_DOMAIN_NAME);
 259         return NULL;
 260     }
 261
 262     if (!domain)
 263         domain = server->domain_name;
 264
 265     if (!AVAHI_VALID_FLAGS(flags, AVAHI_LOOKUP_USE_WIDE_AREA|AVAHI_LOOKUP_USE_MULTICAST)) {
 266         avahi_server_set_errno(server, AVAHI_ERR_INVALID_FLAGS);
 267         return NULL;
 268     }
 269
 270     if (!(b = avahi_new(AvahiSDNSServerBrowser, 1))) {
 271         avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY);
 272         return NULL;
 273     }
 274
 275     b->server = server;
 276     b->domain_name = avahi_normalize_name(domain);
 277     b->callback = callback;
 278     b->userdata = userdata;
 279     b->aprotocol = aprotocol;
 280     b->n_info = 0;
 281     b->user_flags = flags;
 282
 283     AVAHI_LLIST_HEAD_INIT(AvahiDNSServerInfo, b->info);
 284     AVAHI_LLIST_PREPEND(AvahiSDNSServerBrowser, browser, server->dns_server_browsers, b);
 285
 286     n = avahi_strdup_printf("%s.%s",type == AVAHI_DNS_SERVER_RESOLVE ? "_domain._udp" : "_dns-update._udp", b->domain_name);
 287     k = avahi_key_new(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV);
 288     avahi_free(n);
 289
 290     b->record_browser = avahi_s_record_browser_new(server, interface, protocol, k, flags, record_browser_callback, b);
 291     avahi_key_unref(k);
 292
 293     if (!b->record_browser) {
 294         avahi_s_dns_server_browser_free(b);
 295         return NULL;
 296     }
 297
 298     return b;
 299 }
 300
 301 void avahi_s_dns_server_browser_free(AvahiSDNSServerBrowser *b) {
 302     assert(b);
 303
 304     while (b->info)
 305         server_info_free(b, b->info);
 306
 307     AVAHI_LLIST_REMOVE(AvahiSDNSServerBrowser, browser, b->server->dns_server_browsers, b);
 308
 309     if (b->record_browser)
 310         avahi_s_record_browser_free(b->record_browser);
 311     avahi_free(b->domain_name);
 312     avahi_free(b);
 313 }
 314