git.meshlink.io Git - catta/blob - avahi-core/resolve-service.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 #include <stdio.h>
  28 #include <stdlib.h>
  29
  30 #include <avahi-common/domain.h>
  31 #include <avahi-common/timeval.h>
  32 #include <avahi-common/malloc.h>
  33 #include <avahi-common/error.h>
  34
  35 #include "browse.h"
  36 #include "log.h"
  37
  38 #define TIMEOUT_MSEC 5000
  39
  40 struct AvahiSServiceResolver {
  41     AvahiServer *server;
  42     char *service_name;
  43     char *service_type;
  44     char *domain_name;
  45     AvahiProtocol address_protocol;
  46
  47     AvahiIfIndex interface;
  48     AvahiProtocol protocol;
  49
  50     AvahiSRecordBrowser *record_browser_srv;
  51     AvahiSRecordBrowser *record_browser_txt;
  52     AvahiSRecordBrowser *record_browser_a;
  53     AvahiSRecordBrowser *record_browser_aaaa;
  54
  55     AvahiRecord *srv_record, *txt_record, *address_record;
  56     AvahiLookupResultFlags srv_flags, txt_flags, address_flags;
  57
  58     AvahiSServiceResolverCallback callback;
  59     void* userdata;
  60     AvahiLookupFlags user_flags;
  61
  62     AvahiTimeEvent *time_event;
  63
  64     AVAHI_LLIST_FIELDS(AvahiSServiceResolver, resolver);
  65 };
  66
  67 static void finish(AvahiSServiceResolver *r, AvahiResolverEvent event) {
  68     AvahiLookupResultFlags flags;
  69
  70     assert(r);
  71
  72     if (r->time_event) {
  73         avahi_time_event_free(r->time_event);
  74         r->time_event = NULL;
  75     }
  76
  77     flags =
  78         r->txt_flags |
  79         r->srv_flags |
  80         r->address_flags;
  81
  82     switch (event) {
  83         case AVAHI_RESOLVER_FAILURE:
  84         case AVAHI_RESOLVER_NOT_FOUND:
  85         case AVAHI_RESOLVER_TIMEOUT:
  86
  87             r->callback(
  88                 r,
  89                 r->interface,
  90                 r->protocol,
  91                 event,
  92                 r->service_name,
  93                 r->service_type,
  94                 r->domain_name,
  95                 NULL,
  96                 NULL,
  97                 0,
  98                 NULL,
  99                 flags,
 100                 r->userdata);
 101
 102             break;
 103
 104         case AVAHI_RESOLVER_FOUND: {
 105             AvahiAddress a;
 106
 107             assert(event == AVAHI_RESOLVER_FOUND);
 108
 109             assert(r->srv_record);
 110
 111             if (r->address_record) {
 112                 switch (r->address_record->key->type) {
 113                     case AVAHI_DNS_TYPE_A:
 114                         a.proto = AVAHI_PROTO_INET;
 115                         a.data.ipv4 = r->address_record->data.a.address;
 116                         break;
 117
 118                     case AVAHI_DNS_TYPE_AAAA:
 119                         a.proto = AVAHI_PROTO_INET6;
 120                         a.data.ipv6 = r->address_record->data.aaaa.address;
 121                         break;
 122
 123                     default:
 124                         assert(0);
 125                 }
 126             }
 127
 128             r->callback(
 129                 r,
 130                 r->interface,
 131                 r->protocol,
 132                 event,
 133                 r->service_name,
 134                 r->service_type,
 135                 r->domain_name,
 136                 r->address_record ? r->address_record->key->name : r->srv_record->data.srv.name,
 137                 r->address_record ? &a : NULL,
 138                 r->srv_record->data.srv.port,
 139                 r->txt_record ? r->txt_record->data.txt.string_list : NULL,
 140                 flags,
 141                 r->userdata);
 142
 143             break;
 144         }
 145     }
 146 }
 147
 148 static void time_event_callback(AvahiTimeEvent *e, void *userdata) {
 149     AvahiSServiceResolver *r = userdata;
 150
 151     assert(e);
 152     assert(r);
 153
 154     avahi_log_debug("timeout");
 155
 156     finish(r, AVAHI_RESOLVER_TIMEOUT);
 157 }
 158
 159 static void start_timeout(AvahiSServiceResolver *r) {
 160     struct timeval tv;
 161     assert(r);
 162
 163     if (r->time_event)
 164         return;
 165
 166     avahi_elapse_time(&tv, TIMEOUT_MSEC, 0);
 167
 168     r->time_event = avahi_time_event_new(r->server->time_event_queue, &tv, time_event_callback, r);
 169 }
 170
 171 static void record_browser_callback(
 172     AvahiSRecordBrowser*rr,
 173     AvahiIfIndex interface,
 174     AvahiProtocol protocol,
 175     AvahiBrowserEvent event,
 176     AvahiRecord *record,
 177     AvahiLookupResultFlags flags,
 178     void* userdata) {
 179
 180     AvahiSServiceResolver *r = userdata;
 181
 182     assert(rr);
 183     assert(r);
 184
 185     if (rr == r->record_browser_aaaa || rr == r->record_browser_a)
 186         r->address_flags = flags;
 187     else if (rr == r->record_browser_srv)
 188         r->srv_flags = flags;
 189     else if (rr == r->record_browser_txt)
 190         r->txt_flags = flags;
 191
 192     switch (event) {
 193
 194         case AVAHI_BROWSER_NEW: {
 195             int changed = 0;
 196             assert(record);
 197
 198             if (r->interface > 0 && interface != r->interface)
 199                 return;
 200
 201             if (r->protocol != AVAHI_PROTO_UNSPEC && protocol != r->protocol)
 202                 return;
 203
 204             if (r->interface <= 0)
 205                 r->interface = interface;
 206
 207             if (r->protocol == AVAHI_PROTO_UNSPEC)
 208                 r->protocol = protocol;
 209
 210             switch (record->key->type) {
 211                 case AVAHI_DNS_TYPE_SRV:
 212                     if (!r->srv_record) {
 213                         r->srv_record = avahi_record_ref(record);
 214                         changed = 1;
 215
 216                         if (r->record_browser_a) {
 217                             avahi_s_record_browser_free(r->record_browser_a);
 218                             r->record_browser_a = NULL;
 219                         }
 220
 221                         if (r->record_browser_aaaa) {
 222                             avahi_s_record_browser_free(r->record_browser_aaaa);
 223                             r->record_browser_aaaa = NULL;
 224                         }
 225
 226                         if (!(r->user_flags & AVAHI_LOOKUP_NO_ADDRESS)) {
 227
 228                             if (r->address_protocol == AVAHI_PROTO_INET || r->address_protocol == AVAHI_PROTO_UNSPEC) {
 229                                 AvahiKey *k = avahi_key_new(r->srv_record->data.srv.name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_A);
 230                                 r->record_browser_a = avahi_s_record_browser_new(r->server, r->interface, r->protocol, k, r->user_flags & ~(AVAHI_LOOKUP_NO_TXT|AVAHI_LOOKUP_NO_ADDRESS), record_browser_callback, r);
 231                                 avahi_key_unref(k);
 232                             }
 233
 234                             if (r->address_protocol == AVAHI_PROTO_INET6 || r->address_protocol == AVAHI_PROTO_UNSPEC) {
 235                                 AvahiKey *k = avahi_key_new(r->srv_record->data.srv.name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_AAAA);
 236                                 r->record_browser_aaaa = avahi_s_record_browser_new(r->server, r->interface, r->protocol, k, r->user_flags & ~(AVAHI_LOOKUP_NO_TXT|AVAHI_LOOKUP_NO_ADDRESS), record_browser_callback, r);
 237                                 avahi_key_unref(k);
 238                             }
 239                         }
 240                     }
 241                     break;
 242
 243                 case AVAHI_DNS_TYPE_TXT:
 244
 245                     assert(!(r->user_flags & AVAHI_LOOKUP_NO_TXT));
 246
 247                     if (!r->txt_record) {
 248                         r->txt_record = avahi_record_ref(record);
 249                         changed = 1;
 250                     }
 251                     break;
 252
 253                 case AVAHI_DNS_TYPE_A:
 254                 case AVAHI_DNS_TYPE_AAAA:
 255
 256                     assert(!(r->user_flags & AVAHI_LOOKUP_NO_ADDRESS));
 257
 258                     if (!r->address_record) {
 259                         r->address_record = avahi_record_ref(record);
 260                         changed = 1;
 261                     }
 262                     break;
 263
 264                 default:
 265                     abort();
 266             }
 267
 268
 269             if (changed &&
 270                 r->srv_record &&
 271                 (r->txt_record || (r->user_flags & AVAHI_LOOKUP_NO_TXT)) &&
 272                 (r->address_record || (r->user_flags & AVAHI_LOOKUP_NO_ADDRESS)))
 273                 finish(r, AVAHI_RESOLVER_FOUND);
 274
 275             break;
 276
 277         }
 278
 279         case AVAHI_BROWSER_REMOVE:
 280
 281             assert(record);
 282
 283             switch (record->key->type) {
 284                 case AVAHI_DNS_TYPE_SRV:
 285
 286                     if (r->srv_record && avahi_record_equal_no_ttl(record, r->srv_record)) {
 287                         avahi_record_unref(r->srv_record);
 288                         r->srv_record = NULL;
 289
 290                         if (r->record_browser_a) {
 291                             avahi_s_record_browser_free(r->record_browser_a);
 292                             r->record_browser_a = NULL;
 293                         }
 294
 295                         if (r->record_browser_aaaa) {
 296                             avahi_s_record_browser_free(r->record_browser_aaaa);
 297                             r->record_browser_aaaa = NULL;
 298                         }
 299
 300                         /** Look for a replacement */
 301                         avahi_s_record_browser_restart(r->record_browser_srv);
 302                         start_timeout(r);
 303                     }
 304
 305                     break;
 306
 307                 case AVAHI_DNS_TYPE_TXT:
 308
 309                     assert(!(r->user_flags & AVAHI_LOOKUP_NO_TXT));
 310
 311                     if (r->txt_record && avahi_record_equal_no_ttl(record, r->txt_record)) {
 312                         avahi_record_unref(r->txt_record);
 313                         r->txt_record = NULL;
 314
 315                         /** Look for a replacement */
 316                         avahi_s_record_browser_restart(r->record_browser_txt);
 317                         start_timeout(r);
 318                     }
 319                     break;
 320
 321                 case AVAHI_DNS_TYPE_A:
 322                 case AVAHI_DNS_TYPE_AAAA:
 323
 324                     assert(!(r->user_flags & AVAHI_LOOKUP_NO_ADDRESS));
 325
 326                     if (r->address_record && avahi_record_equal_no_ttl(record, r->address_record)) {
 327                         avahi_record_unref(r->address_record);
 328                         r->address_record = NULL;
 329
 330                         /** Look for a replacement */
 331                         if (r->record_browser_aaaa)
 332                             avahi_s_record_browser_restart(r->record_browser_aaaa);
 333                         if (r->record_browser_a)
 334                             avahi_s_record_browser_restart(r->record_browser_a);
 335                         start_timeout(r);
 336                     }
 337                     break;
 338
 339                 default:
 340                     abort();
 341             }
 342
 343             break;
 344
 345         case AVAHI_BROWSER_CACHE_EXHAUSTED:
 346         case AVAHI_BROWSER_ALL_FOR_NOW:
 347             break;
 348
 349         case AVAHI_BROWSER_NOT_FOUND:
 350         case AVAHI_BROWSER_FAILURE:
 351
 352             if (r->record_browser_srv)
 353                 avahi_s_record_browser_free(r->record_browser_srv);
 354             if (r->record_browser_txt)
 355                 avahi_s_record_browser_free(r->record_browser_txt);
 356             if (r->record_browser_a)
 357                 avahi_s_record_browser_free(r->record_browser_a);
 358             if (r->record_browser_aaaa)
 359                 avahi_s_record_browser_free(r->record_browser_aaaa);
 360
 361             r->record_browser_srv = r->record_browser_txt = r->record_browser_a = r->record_browser_aaaa = NULL;
 362
 363             finish(r, event == AVAHI_BROWSER_FAILURE ? AVAHI_RESOLVER_FAILURE : AVAHI_RESOLVER_NOT_FOUND);
 364             break;
 365     }
 366 }
 367
 368 AvahiSServiceResolver *avahi_s_service_resolver_new(
 369     AvahiServer *server,
 370     AvahiIfIndex interface,
 371     AvahiProtocol protocol,
 372     const char *name,
 373     const char *type,
 374     const char *domain,
 375     AvahiProtocol aprotocol,
 376     AvahiLookupFlags flags,
 377     AvahiSServiceResolverCallback callback,
 378     void* userdata) {
 379
 380     AvahiSServiceResolver *r;
 381     AvahiKey *k;
 382     char t[256];
 383
 384     assert(server);
 385     assert(type);
 386     assert(callback);
 387
 388     assert(aprotocol == AVAHI_PROTO_UNSPEC || aprotocol == AVAHI_PROTO_INET || aprotocol == AVAHI_PROTO_INET6);
 389
 390     if (!AVAHI_IF_VALID(interface)) {
 391         avahi_server_set_errno(server, AVAHI_ERR_INVALID_INTERFACE);
 392         return NULL;
 393     }
 394
 395     if (name && !avahi_is_valid_service_name(name)) {
 396         avahi_server_set_errno(server, AVAHI_ERR_INVALID_SERVICE_NAME);
 397         return NULL;
 398     }
 399
 400     if (!avahi_is_valid_service_type(type)) {
 401         avahi_server_set_errno(server, AVAHI_ERR_INVALID_SERVICE_TYPE);
 402         return NULL;
 403     }
 404
 405     if (domain && !avahi_is_valid_domain_name(domain)) {
 406         avahi_server_set_errno(server, AVAHI_ERR_INVALID_DOMAIN_NAME);
 407         return NULL;
 408     }
 409
 410     if (!domain)
 411         domain = server->domain_name;
 412
 413     if (!AVAHI_VALID_FLAGS(flags, AVAHI_LOOKUP_USE_WIDE_AREA|AVAHI_LOOKUP_USE_MULTICAST|AVAHI_LOOKUP_NO_TXT|AVAHI_LOOKUP_NO_ADDRESS)) {
 414         avahi_server_set_errno(server, AVAHI_ERR_INVALID_FLAGS);
 415         return NULL;
 416     }
 417
 418     if (!(r = avahi_new(AvahiSServiceResolver, 1))) {
 419         avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY);
 420         return NULL;
 421     }
 422
 423     r->server = server;
 424     r->service_name = avahi_strdup(name);
 425     r->service_type = avahi_normalize_name(type);
 426     r->domain_name = avahi_normalize_name(domain);
 427     r->callback = callback;
 428     r->userdata = userdata;
 429     r->address_protocol = aprotocol;
 430     r->srv_record = r->txt_record = r->address_record = NULL;
 431     r->srv_flags = r->txt_flags = r->address_flags = 0;
 432     r->interface = interface;
 433     r->protocol = protocol;
 434     r->user_flags = flags;
 435
 436     if (name) {
 437         char *n;
 438         size_t l;
 439
 440         n = t;
 441         l = sizeof(t);
 442         avahi_escape_label((const uint8_t*) name, strlen(name), &n, &l);
 443         snprintf(n, l, ".%s.%s", r->service_type, r->domain_name);
 444     } else
 445         snprintf(t, sizeof(t), "%s.%s", r->service_type, r->domain_name);
 446
 447     r->time_event = NULL;
 448
 449     AVAHI_LLIST_PREPEND(AvahiSServiceResolver, resolver, server->service_resolvers, r);
 450
 451     r->record_browser_a = r->record_browser_aaaa = r->record_browser_srv = r->record_browser_txt = NULL;
 452
 453     k = avahi_key_new(t, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV);
 454     r->record_browser_srv = avahi_s_record_browser_new(server, interface, protocol, k, flags & ~(AVAHI_LOOKUP_NO_TXT|AVAHI_LOOKUP_NO_ADDRESS), record_browser_callback, r);
 455     avahi_key_unref(k);
 456
 457     if (!r->record_browser_srv) {
 458         avahi_s_service_resolver_free(r);
 459         return NULL;
 460     }
 461
 462     if (!(flags & AVAHI_LOOKUP_NO_TXT)) {
 463         k = avahi_key_new(t, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_TXT);
 464         r->record_browser_txt = avahi_s_record_browser_new(server, interface, protocol, k, flags & ~(AVAHI_LOOKUP_NO_TXT|AVAHI_LOOKUP_NO_ADDRESS),  record_browser_callback, r);
 465         avahi_key_unref(k);
 466
 467         if (!r->record_browser_txt) {
 468             avahi_s_service_resolver_free(r);
 469             return NULL;
 470         }
 471     }
 472
 473     start_timeout(r);
 474
 475     return r;
 476 }
 477
 478 void avahi_s_service_resolver_free(AvahiSServiceResolver *r) {
 479     assert(r);
 480
 481     AVAHI_LLIST_REMOVE(AvahiSServiceResolver, resolver, r->server->service_resolvers, r);
 482
 483     if (r->time_event)
 484         avahi_time_event_free(r->time_event);
 485
 486     if (r->record_browser_srv)
 487         avahi_s_record_browser_free(r->record_browser_srv);
 488     if (r->record_browser_txt)
 489         avahi_s_record_browser_free(r->record_browser_txt);
 490     if (r->record_browser_a)
 491         avahi_s_record_browser_free(r->record_browser_a);
 492     if (r->record_browser_aaaa)
 493         avahi_s_record_browser_free(r->record_browser_aaaa);
 494
 495     if (r->srv_record)
 496         avahi_record_unref(r->srv_record);
 497     if (r->txt_record)
 498         avahi_record_unref(r->txt_record);
 499     if (r->address_record)
 500         avahi_record_unref(r->address_record);
 501
 502     avahi_free(r->service_name);
 503     avahi_free(r->service_type);
 504     avahi_free(r->domain_name);
 505     avahi_free(r);
 506 }