--- /usr/tmp/clean/avahi-0.6.12/avahi-core/resolve-service.c	2006-04-01 01:48:59.000000000 +0100

+++ avahi-0.6.12/avahi-core/resolve-service.c	2006-08-28 14:40:21.749772000 +0100

@@ -27,6 +27,10 @@

 #include <stdio.h>

 #include <stdlib.h>

+#ifdef HAVE_BONJOUR

+#include <netinet/in.h> /* for ntohs */

+#endif

+

 #include <avahi-common/domain.h>

 #include <avahi-common/timeval.h>

 #include <avahi-common/malloc.h>

@@ -61,9 +65,302 @@

     AvahiTimeEvent *time_event;

+#ifdef HAVE_BONJOUR

+    uint16_t port;

+    AvahiTimeEvent *defer_time_event;

+    char *host;

+    AvahiWatch *watch;

+    AvahiWatch *watch_a;

+    AvahiWatch *watch_a6;

+    DNSServiceRef client;

+    DNSServiceRef client_a;

+    DNSServiceRef client_a6;

+#endif

+

     AVAHI_LLIST_FIELDS(AvahiSServiceResolver, resolver);

 };

+

+#ifdef HAVE_BONJOUR

+static void finish(AvahiSServiceResolver *r, AvahiResolverEvent event ) {

+    AvahiLookupResultFlags flags;

+

+    assert(r);

+

+    if (r->time_event) {

+        avahi_time_event_free(r->time_event);

+        r->time_event = NULL;

+    }

+

+    flags = 0;

+

+    switch (event) {

+        case AVAHI_RESOLVER_FAILURE:

+

+            r->callback(r, 

+                r->interface, 

+                r->protocol, 

+                event, 

+                r->service_name, 

+                r->service_type, 

+                r->domain_name, 

+                NULL, 

+                NULL, 

+                0, 

+                NULL, 

+                flags, 

+                r->userdata);

+            break;

+

+        case AVAHI_RESOLVER_FOUND: {

+            AvahiAddress a;

+

+            if (r->address_record) {

+                switch (r->address_record->key->type) {

+                    case AVAHI_DNS_TYPE_A:

+                        a.proto = AVAHI_PROTO_INET;

+                        a.data.ipv4 = r->address_record->data.a.address;

+                        break;

+

+                    case AVAHI_DNS_TYPE_AAAA:

+                        a.proto = AVAHI_PROTO_INET6;

+                        a.data.ipv6 = r->address_record->data.aaaa.address;

+                        break;

+

+                    default:

+                        assert(0);

+                }

+            }

+

+            flags = 0;

+            if (avahi_domain_equal(r->server->host_name_fqdn, r->host))

+                flags |= AVAHI_LOOKUP_RESULT_LOCAL;

+            r->callback(r, 

+                r->interface, 

+                r->protocol, 

+                event, 

+                r->service_name, 

+                r->service_type, 

+                r->domain_name, 

+                r->host, 

+                r->address_record ? &a : NULL, 

+                r->port, 

+                r->txt_record ? r->txt_record->data.txt.string_list : NULL, 

+                flags, 

+                r->userdata);

+            break;

+        }

+    }

+}

+

+static  void query_record(DNSServiceRef sdRef, const DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode,

+        const char *fullname, uint16_t rrtype, uint16_t rrclass, uint16_t rdlen, const void *rdata, uint32_t ttl, void *context)

+{

+    AvahiSServiceResolver *r = context;

+    const unsigned char *rd = rdata;

+    AvahiAddress a;

+    int changed = 0;

+

+    if (r->interface > 0 && ifIndex != r->interface)

+        return;

+    if (r->interface <= 0)

+        r->interface = ifIndex;

+

+    switch (rrtype) {

+        case kDNSServiceType_A:

+            if (!r->address_record) {

+                if (!(r->address_record = avahi_record_new_full(r->host, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_A, ttl))) {

+                    avahi_server_set_errno(r->server, AVAHI_ERR_NO_MEMORY);

+                    finish(r, AVAHI_RESOLVER_FAILURE);

+                    return;

+                }

+                if (avahi_rdata_parse(r->address_record, rdata, rdlen) != 0) {

+                    avahi_server_set_errno(r->server, AVAHI_ERR_INVALID_PACKET);

+                    finish(r, AVAHI_RESOLVER_FAILURE);

+                }

+                changed = 1;

+                if (r->protocol == AVAHI_PROTO_UNSPEC)

+                    r->protocol = AVAHI_PROTO_INET;

+            }

+            break;

+

+        case kDNSServiceType_A6:

+            if (!r->address_record) {

+                if (!(r->address_record = avahi_record_new_full(r->host, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_AAAA, ttl))) {

+                    avahi_server_set_errno(r->server, AVAHI_ERR_NO_MEMORY);

+                    finish(r, AVAHI_RESOLVER_FAILURE);

+                    return;

+                }

+                if (avahi_rdata_parse(r->address_record, rdata, rdlen) != 0) {

+                    avahi_server_set_errno(r->server, AVAHI_ERR_INVALID_PACKET);

+                    finish(r, AVAHI_RESOLVER_FAILURE);

+                }

+                changed = 1;

+                if (r->protocol == AVAHI_PROTO_UNSPEC)

+                    r->protocol = AVAHI_PROTO_INET6;

+            }

+            break;

+        default:

+            abort();

+    }

+

+    if (changed &&

+        (r->txt_record || (r->user_flags & AVAHI_LOOKUP_NO_TXT)) &&

+        r->address_record || (r->user_flags & AVAHI_LOOKUP_NO_ADDRESS)) {

+        finish(r, AVAHI_RESOLVER_FOUND);

+   }

+}

+

+static void resolve_socket_event(AvahiWatch *w, int fd, AvahiWatchEvent events, void *userdata) {

+    AvahiSServiceResolver *r = userdata;

+    DNSServiceErrorType ret;

+    DNSServiceRef client;

+

+    assert(w);

+    assert(fd >= 0);

+    assert(events & AVAHI_WATCH_IN);

+

+    if (fd == DNSServiceRefSockFD(r->client))

+        client = r->client;

+    else if (fd == DNSServiceRefSockFD(r->client_a))

+        client = r->client_a;

+    else if (fd == DNSServiceRefSockFD(r->client_a6))

+        client = r->client_a6;

+    else

+        assert (0);

+

+    ret = DNSServiceProcessResult(client);

+    if (ret != kDNSServiceErr_NoError) {

+        if (client == r->client) {

+            if (r->watch) {

+                r->server->poll_api->watch_free(r->watch);

+                r->watch = NULL;

+            }

+            DNSServiceRefDeallocate(r->client);

+            r->client = NULL; 

+        } else if (client == r->client_a) {

+            if (r->watch_a) {

+                r->server->poll_api->watch_free(r->watch_a);

+                r->watch_a = NULL;

+            }

+            DNSServiceRefDeallocate(r->client_a);

+            r->client_a = NULL; 

+        } else if (client == r->client_a6) {

+            if (r->watch_a6) {

+                r->server->poll_api->watch_free(r->watch_a6);

+                r->watch_a6 = NULL;

+            }

+            DNSServiceRefDeallocate(r->client_a6);

+            r->client_a6 = NULL; 

+        }

+        avahi_server_set_errno(r->server, AVAHI_ERR_DISCONNECTED);

+        finish(r, AVAHI_RESOLVER_FAILURE);

+    }

+}

+

+static void resolve_reply(DNSServiceRef client, const DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode,

+        const char *fullname, const char *host, uint16_t opaqueport, uint16_t txtlen, const char* txtrecord, void *context) {

+    AvahiSServiceResolver *r = context;

+    AvahiServer *s = r->server;

+    DNSServiceErrorType ret;

+    DNSServiceRef new_client;

+

+    if (r->interface > 0 && ifIndex != r->interface)

+        return;

+    if (r->interface <= 0)

+        r->interface = ifIndex;

+

+    if (host) {

+        if (!(r->host = avahi_strdup(host))) {

+            avahi_server_set_errno(r->server, AVAHI_ERR_NO_MEMORY);

+            finish(r, AVAHI_RESOLVER_FAILURE);

+        }

+    }

+    if (!(r->user_flags & AVAHI_LOOKUP_NO_ADDRESS)) {

+        if (!r->txt_record) {

+            if (!(r->txt_record = avahi_record_new_full(r->host, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_TXT, AVAHI_DEFAULT_TTL))) {

+                avahi_server_set_errno(r->server, AVAHI_ERR_NO_MEMORY);

+                finish(r, AVAHI_RESOLVER_FAILURE);

+                return;

+            }

+        }

+        if (avahi_rdata_parse(r->txt_record, txtrecord, txtlen) != 0) {

+            avahi_server_set_errno(r->server, AVAHI_ERR_INVALID_PACKET);

+            finish(r, AVAHI_RESOLVER_FAILURE);

+        }

+    }

+    r->port = ntohs(opaqueport);

+    if (!(r->user_flags & AVAHI_LOOKUP_NO_ADDRESS)) {

+        if (r->address_protocol == AVAHI_PROTO_INET || r->address_protocol == AVAHI_PROTO_UNSPEC) {

+            if (r->client_a) {

+                if (r->watch_a) {

+                    r->server->poll_api->watch_free(r->watch_a);

+                    r->watch_a = NULL;

+                }

+                DNSServiceRefDeallocate(r->client_a);

+                r->client_a = NULL;

+            }

+            ret = DNSServiceQueryRecord(&r->client_a, 0, ifIndex, host, kDNSServiceType_A, kDNSServiceClass_IN, query_record, r);

+            if (ret != kDNSServiceErr_NoError || !r->client_a) {

+                finish(r, AVAHI_RESOLVER_FAILURE);

+                return;

+            }

+            r->watch_a = s->poll_api->watch_new(s->poll_api, DNSServiceRefSockFD(r->client_a), AVAHI_WATCH_IN, resolve_socket_event, r);

+        }

+

+        if (r->address_protocol == AVAHI_PROTO_INET6 || r->address_protocol == AVAHI_PROTO_UNSPEC) {

+            if (r->client_a6) {

+                if (r->watch_a6) {

+                    r->server->poll_api->watch_free(r->watch_a6);

+                    r->watch_a6 = NULL;

+                }

+                DNSServiceRefDeallocate(r->client_a6);

+                r->client_a6 = NULL;

+            }

+            ret = DNSServiceQueryRecord(&r->client_a6, 0, ifIndex, host, kDNSServiceType_A6, kDNSServiceClass_IN, query_record, r);

+            if (ret != kDNSServiceErr_NoError || !r->client_a6) {

+                finish(r, AVAHI_RESOLVER_FAILURE);

+                return;

+            }

+            r->watch_a6 = s->poll_api->watch_new(s->poll_api, DNSServiceRefSockFD(r->client_a6), AVAHI_WATCH_IN, resolve_socket_event, r);

+        }

+    } else {

+       finish(r, AVAHI_RESOLVER_FOUND);

+    }

+}

+

+static void resolve_error_callback(AvahiTimeEvent *e, void *userdata) {

+    AvahiSServiceResolver *r = userdata;

+

+    if (r->defer_time_event) {

+        avahi_time_event_free(r->defer_time_event);

+        r->defer_time_event = NULL;

+    }

+    avahi_server_set_errno(r->server, AVAHI_ERR_FAILURE);

+    finish(r, AVAHI_RESOLVER_FAILURE);

+}

+

+static void avahi_resolve_service_start(AvahiServer *s, AvahiSServiceResolver *r) {

+    DNSServiceErrorType ret;

+

+    ret = DNSServiceResolve(&r->client, 

+              0,

+              r->interface == AVAHI_IF_UNSPEC ? 

+                  kDNSServiceInterfaceIndexAny :

+                  r->interface,

+              r->service_name,

+              r->service_type,

+              r->domain_name,

+              resolve_reply,

+              r);

+    if (ret != kDNSServiceErr_NoError || !r->client) {

+        r->defer_time_event = avahi_time_event_new(r->server->time_event_queue, NULL, resolve_error_callback, r);

+    } else {

+        r->watch = s->poll_api->watch_new(s->poll_api, DNSServiceRefSockFD(r->client), AVAHI_WATCH_IN, resolve_socket_event, r);

+    }

+}

+#else

+

 static void finish(AvahiSServiceResolver *r, AvahiResolverEvent event) {

     AvahiLookupResultFlags flags;

@@ -142,6 +439,7 @@

         }

     }

 }

+#endif

 static void time_event_callback(AvahiTimeEvent *e, void *userdata) {

     AvahiSServiceResolver *r = userdata;

@@ -165,6 +463,7 @@

     r->time_event = avahi_time_event_new(r->server->time_event_queue, &tv, time_event_callback, r);

 }

+#ifndef HAVE_BONJOUR

 static void record_browser_callback(

     AvahiSRecordBrowser*rr,

     AvahiIfIndex interface,

@@ -376,6 +675,7 @@

             break;

     }

 }

+#endif

 AvahiSServiceResolver *avahi_s_service_resolver_new(

     AvahiServer *server,

@@ -435,6 +735,17 @@

     r->time_event = NULL;

     AVAHI_LLIST_PREPEND(AvahiSServiceResolver, resolver, server->service_resolvers, r);

+#ifdef HAVE_BONJOUR

+    r->defer_time_event = NULL;

+    r->host = NULL;

+    r->watch = NULL;

+    r->watch_a = NULL;

+    r->watch_a6 = NULL;

+    r->client = NULL;

+    r->client_a = NULL;

+    r->client_a6 = NULL;

+    avahi_resolve_service_start(server, r);

+#else

     k = avahi_key_new(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV);

     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);

     avahi_key_unref(k);

@@ -454,6 +765,7 @@

             return NULL;

         }

     }

+#endif

     start_timeout(r);

@@ -484,6 +796,29 @@

     if (r->address_record)

         avahi_record_unref(r->address_record);

+#ifdef HAVE_BONJOUR

+    if (r->defer_time_event) {

+        avahi_time_event_free(r->defer_time_event);

+        r->defer_time_event = NULL;

+    }

+

+    if (r->host)

+        avahi_free(r->host);

+

+    if (r->watch)

+        r->server->poll_api->watch_free(r->watch);

+    if (r->watch_a)

+        r->server->poll_api->watch_free(r->watch_a);

+    if (r->watch_a6)

+        r->server->poll_api->watch_free(r->watch_a6);

+

+    if (r->client)

+        DNSServiceRefDeallocate (r->client);

+    if (r->client_a)

+        DNSServiceRefDeallocate (r->client_a);

+    if (r->client_a6)

+        DNSServiceRefDeallocate (r->client_a6);

+#endif

     avahi_free(r->service_name);

     avahi_free(r->service_type);

     avahi_free(r->domain_name);