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 > 0 &&  interface != r->interface)
 199                 return;
 200
 201             if (r->protocol != AVAHI_PROTO_UNSPEC && 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
 353             if (rr == r->record_browser_a && r->record_browser_aaaa) {
 354                 /* We were looking for both AAAA and A, and the other query is still living, so we'll not die */
 355                 avahi_s_record_browser_free(r->record_browser_a);
 356                 r->record_browser_a = NULL;
 357                 break;
 358             }
 359
 360             if (rr == r->record_browser_aaaa && r->record_browser_a) {
 361                 /* We were looking for both AAAA and A, and the other query is still living, so we'll not die */
 362                 avahi_s_record_browser_free(r->record_browser_aaaa);
 363                 r->record_browser_aaaa = NULL;
 364                 break;
 365             }
 366
 367
 368             /* Hmm, everything's lost, tell the user */
 369
 370             if (r->record_browser_srv)
 371                 avahi_s_record_browser_free(r->record_browser_srv);
 372             if (r->record_browser_txt)
 373                 avahi_s_record_browser_free(r->record_browser_txt);
 374             if (r->record_browser_a)
 375                 avahi_s_record_browser_free(r->record_browser_a);
 376             if (r->record_browser_aaaa)
 377                 avahi_s_record_browser_free(r->record_browser_aaaa);
 378
 379             r->record_browser_srv = r->record_browser_txt = r->record_browser_a = r->record_browser_aaaa = NULL;
 380
 381             finish(r, event == AVAHI_BROWSER_FAILURE ? AVAHI_RESOLVER_FAILURE : AVAHI_RESOLVER_NOT_FOUND);
 382             break;
 383     }
 384 }
 385
 386 AvahiSServiceResolver *avahi_s_service_resolver_new(
 387     AvahiServer *server,
 388     AvahiIfIndex interface,
 389     AvahiProtocol protocol,
 390     const char *name,
 391     const char *type,
 392     const char *domain,
 393     AvahiProtocol aprotocol,
 394     AvahiLookupFlags flags,
 395     AvahiSServiceResolverCallback callback,
 396     void* userdata) {
 397
 398     AvahiSServiceResolver *r;
 399     AvahiKey *k;
 400     char t[256];
 401     int ret;
 402
 403     assert(server);
 404     assert(type);
 405     assert(callback);
 406
 407     assert(aprotocol == AVAHI_PROTO_UNSPEC || aprotocol == AVAHI_PROTO_INET || aprotocol == AVAHI_PROTO_INET6);
 408
 409     if (!AVAHI_IF_VALID(interface)) {
 410         avahi_server_set_errno(server, AVAHI_ERR_INVALID_INTERFACE);
 411         return NULL;
 412     }
 413
 414     if (name && !avahi_is_valid_service_name(name)) {
 415         avahi_server_set_errno(server, AVAHI_ERR_INVALID_SERVICE_NAME);
 416         return NULL;
 417     }
 418
 419     if (!avahi_is_valid_service_type(type)) {
 420         avahi_server_set_errno(server, AVAHI_ERR_INVALID_SERVICE_TYPE);
 421         return NULL;
 422     }
 423
 424     if (domain && !avahi_is_valid_domain_name(domain)) {
 425         avahi_server_set_errno(server, AVAHI_ERR_INVALID_DOMAIN_NAME);
 426         return NULL;
 427     }
 428
 429     if (!domain)
 430         domain = server->domain_name;
 431
 432     if (!AVAHI_FLAGS_VALID(flags, AVAHI_LOOKUP_USE_WIDE_AREA|AVAHI_LOOKUP_USE_MULTICAST|AVAHI_LOOKUP_NO_TXT|AVAHI_LOOKUP_NO_ADDRESS)) {
 433         avahi_server_set_errno(server, AVAHI_ERR_INVALID_FLAGS);
 434         return NULL;
 435     }
 436
 437     if (!(r = avahi_new(AvahiSServiceResolver, 1))) {
 438         avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY);
 439         return NULL;
 440     }
 441
 442     r->server = server;
 443     r->service_name = avahi_strdup(name);
 444     r->service_type = avahi_normalize_name(type);
 445     r->domain_name = avahi_normalize_name(domain);
 446     r->callback = callback;
 447     r->userdata = userdata;
 448     r->address_protocol = aprotocol;
 449     r->srv_record = r->txt_record = r->address_record = NULL;
 450     r->srv_flags = r->txt_flags = r->address_flags = 0;
 451     r->interface = interface;
 452     r->protocol = protocol;
 453     r->user_flags = flags;
 454     r->record_browser_a = r->record_browser_aaaa = r->record_browser_srv = r->record_browser_txt = NULL;
 455     r->time_event = NULL;
 456     AVAHI_LLIST_PREPEND(AvahiSServiceResolver, resolver, server->service_resolvers, r);
 457
 458     if ((ret = avahi_service_name_snprint(t, sizeof(t), name, r->service_type, r->domain_name)) < 0) {
 459         avahi_server_set_errno(server, ret);
 460         avahi_s_service_resolver_free(r);
 461         return NULL;
 462     }
 463
 464     k = avahi_key_new(t, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV);
 465     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);
 466     avahi_key_unref(k);
 467
 468     if (!r->record_browser_srv) {
 469         avahi_s_service_resolver_free(r);
 470         return NULL;
 471     }
 472
 473     if (!(flags & AVAHI_LOOKUP_NO_TXT)) {
 474         k = avahi_key_new(t, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_TXT);
 475         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);
 476         avahi_key_unref(k);
 477
 478         if (!r->record_browser_txt) {
 479             avahi_s_service_resolver_free(r);
 480             return NULL;
 481         }
 482     }
 483
 484     start_timeout(r);
 485
 486     return r;
 487 }
 488
 489 void avahi_s_service_resolver_free(AvahiSServiceResolver *r) {
 490     assert(r);
 491
 492     AVAHI_LLIST_REMOVE(AvahiSServiceResolver, resolver, r->server->service_resolvers, r);
 493
 494     if (r->time_event)
 495         avahi_time_event_free(r->time_event);
 496
 497     if (r->record_browser_srv)
 498         avahi_s_record_browser_free(r->record_browser_srv);
 499     if (r->record_browser_txt)
 500         avahi_s_record_browser_free(r->record_browser_txt);
 501     if (r->record_browser_a)
 502         avahi_s_record_browser_free(r->record_browser_a);
 503     if (r->record_browser_aaaa)
 504         avahi_s_record_browser_free(r->record_browser_aaaa);
 505
 506     if (r->srv_record)
 507         avahi_record_unref(r->srv_record);
 508     if (r->txt_record)
 509         avahi_record_unref(r->txt_record);
 510     if (r->address_record)
 511         avahi_record_unref(r->address_record);
 512
 513     avahi_free(r->service_name);
 514     avahi_free(r->service_type);
 515     avahi_free(r->domain_name);
 516     avahi_free(r);
 517 }