xref: /jds/spec-files/trunk/patches/avahi-03-entry.diff

--- /usr/tmp/clean/avahi-0.6.12/avahi-core/entry.c	2006-03-02 01:30:17.000000000 +0000
+++ avahi-0.6.12/avahi-core/entry.c	2006-08-28 14:26:37.958555000 +0100
@@ -52,6 +52,33 @@
 #include "rr-util.h"
 #include "domain-util.h"
 
+#ifdef HAVE_BONJOUR
+
+struct AvahiService {
+    AvahiServer *server;
+    AvahiSEntryGroup *group;
+
+    int dead;
+
+    AvahiPublishFlags flags;
+    AvahiIfIndex interface;
+    AvahiProtocol protocol;
+
+    char *name;
+    char *type;
+    char *domain;
+    char *host;
+    uint16_t port;
+
+    AvahiWatch *watch;
+    DNSServiceRef client;
+    size_t txtlen;
+    uint8_t *txtrecord;
+
+    AVAHI_LLIST_FIELDS(AvahiService, services);
+};
+#endif
+
 static void transport_flags_from_domain(AvahiServer *s, AvahiPublishFlags *flags, const char *domain) {
     assert(flags);
     assert(domain);
@@ -71,13 +98,146 @@
         *flags |= AVAHI_PUBLISH_USE_WIDE_AREA;
 }
 
+#ifdef HAVE_BONJOUR
+static void register_service_reply(DNSServiceRef client, const DNSServiceFlags flags, DNSServiceErrorType errorCode,
+        const char *name, const char *regtype, const char *domain, void *context) {
+    AvahiService *as = context;
+
+    switch (errorCode) {
+        case kDNSServiceErr_NoError:
+            as->group->n_probing--;
+            if (as->group->n_probing == 0) {
+                avahi_s_entry_group_change_state(as->group, AVAHI_ENTRY_GROUP_ESTABLISHED);
+            }
+            break;
+        case kDNSServiceErr_NameConflict:
+            avahi_s_entry_group_change_state(as->group, AVAHI_ENTRY_GROUP_COLLISION);
+            break;
+        default: 
+            avahi_s_entry_group_change_state(as->group, AVAHI_ENTRY_GROUP_FAILURE);
+    }
+}
+
+static void register_service_socket_event(AvahiWatch *w, int fd, AvahiWatchEvent events, void *userdata) {
+    AvahiService *as = userdata;
+    DNSServiceErrorType ret;
+
+    assert(w);
+    assert(fd >= 0);
+    assert(events & AVAHI_WATCH_IN);
+
+    assert (fd == DNSServiceRefSockFD(as->client));
+    ret = DNSServiceProcessResult(as->client);
+    if (ret != kDNSServiceErr_NoError) {
+        if (as->watch) {
+            as->server->poll_api->watch_free(as->watch);
+            as->watch = NULL;
+        }
+        DNSServiceRefDeallocate(as->client);
+        as->client = NULL;
+        avahi_s_entry_group_change_state(as->group, AVAHI_ENTRY_GROUP_FAILURE);
+    }
+}
+
+static void avahi_service_free(AvahiServer*s, AvahiService *as) {
+    AvahiService *t;
+
+    assert(s);
+    assert(as);
+
+    /* Remove from linked list */
+    AVAHI_LLIST_REMOVE(AvahiService, services, s->services, as);
+
+    /* Remove from associated group */
+    if (as->group)
+        AVAHI_LLIST_REMOVE(AvahiService, services, as->group->services, as);
+
+    if (as->name)
+        avahi_free(as->name);
+
+    if (as->type)
+        avahi_free(as->type);
+
+    if (as->domain)
+        avahi_free(as->domain);
+
+    if (as->host)
+        avahi_free(as->host);
+
+    if (as->watch)
+        s->poll_api->watch_free(as->watch);
+    
+    if (as->client)
+        DNSServiceRefDeallocate (as->client);
+
+    if (as->txtrecord)
+        avahi_free(as->txtrecord);
+
+    avahi_free(as);
+}
+
+static void avahi_register_service(AvahiServer *s, AvahiService *as) {
+    DNSServiceErrorType ret;
+
+    ret = DNSServiceRegister(&as->client, 
+              as->interface == AVAHI_IF_UNSPEC ? 
+                  kDNSServiceInterfaceIndexAny :
+                  as->interface,
+              0, 
+              as->name,
+              as->type,
+              as->domain,
+              as->host,
+              htons(as->port),
+              as->txtlen,
+              as->txtrecord,
+              register_service_reply,
+              as);
+    if (ret == kDNSServiceErr_NoError) {
+        if  (!as->client) {
+            avahi_s_entry_group_change_state(as->group, AVAHI_ENTRY_GROUP_FAILURE);
+        } else {
+            as->group->n_probing++;
+            as->watch = s->poll_api->watch_new(s->poll_api, DNSServiceRefSockFD(as->client), AVAHI_WATCH_IN, register_service_socket_event, as);
+        } 
+    } else {
+        if (ret == kDNSServiceErr_NameConflict) {
+            avahi_s_entry_group_change_state(as->group, AVAHI_ENTRY_GROUP_COLLISION);
+        }
+        else {
+            avahi_s_entry_group_change_state(as->group, AVAHI_ENTRY_GROUP_FAILURE);
+        }
+    }
+}
+
+static void register_record_reply(DNSServiceRef client, DNSRecordRef recordref, const DNSServiceFlags flags, DNSServiceErrorType errorCode, void *context) {
+    AvahiEntry *e = context;
+    DNSServiceErrorType ret;
+    
+    switch (errorCode) {
+        case kDNSServiceErr_NoError:
+            break;
+        case kDNSServiceErr_NameConflict:
+            e->recordref = NULL;
+            avahi_server_set_errno(e->server, AVAHI_ERR_COLLISION);
+            break;
+        default: 
+            e->recordref = NULL;
+            avahi_server_set_errno(e->server, AVAHI_ERR_FAILURE);
+            break;
+    }
+}
+#endif
+
 void avahi_entry_free(AvahiServer*s, AvahiEntry *e) {
     AvahiEntry *t;
 
     assert(s);
     assert(e);
 
+#ifndef HAVE_BONJOUR
     avahi_goodbye_entry(s, e, 1, 1);
+#endif
 
     /* Remove from linked list */
     AVAHI_LLIST_REMOVE(AvahiEntry, entries, s->entries, e);
@@ -104,6 +264,15 @@
 
     while (g->entries)
         avahi_entry_free(s, g->entries);
+#ifdef HAVE_BONJOUR
+    while (g->services)
+        avahi_service_free(s, g->services);
+
+    if (g->record_connection) {
+        DNSServiceRefDeallocate(g->record_connection);
+        g->record_connection = NULL;
+    }
+#endif
 
     if (g->register_time_event)
         avahi_time_event_free(g->register_time_event);
@@ -141,6 +310,21 @@
         s->need_entry_cleanup = 0;
     }
 
+#ifdef HAVE_BONJOUR
+    if (s->need_service_cleanup) {
+        AvahiService *as, *next;
+        
+        for (as = s->services; as; as = next) {
+            next = as->services_next;
+            
+            if (as->dead)
+                avahi_service_free(s, as);
+        }
+
+        s->need_service_cleanup = 0;
+    }
+#endif
+
     if (s->need_browser_cleanup)
         avahi_browser_cleanup(s);
 }
@@ -226,7 +410,7 @@
         int is_first = 1;
         
         /* Update and existing record */
-
+ 
         /* Find the first matching entry */
         for (e = avahi_hashmap_lookup(s->entries_by_key, r->key); e; e = e->by_key_next) {
             if (!e->dead && e->group == g && e->interface == interface && e->protocol == protocol)
@@ -237,8 +421,54 @@
 
         /* Hmm, nothing found? */
         if (!e) {
+#ifdef HAVE_BONJOUR
+            /*
+             * Assume that we are updating a service's primary TXT record
+             * so find the service
+             */
+            DNSServiceErrorType ret;
+            uint16_t rlen;
+            uint8_t rdata[AVAHI_DNS_RDATA_MAX];
+            size_t l;
+            AvahiService *as;
+            int found_as = 0;
+
+            for (as = g->services; as; as = as->services_next) {
+                int a_ret = AVAHI_OK;
+                char svc_name[AVAHI_DOMAIN_NAME_MAX];
+
+                if ((a_ret = avahi_service_name_join(svc_name, sizeof(svc_name), as->name, as->type, as->domain ? as->domain : s->domain_name)) < 0) {
+                      avahi_server_set_errno(s, a_ret);
+                      return NULL;
+                }
+                if (!strcmp(svc_name, r->key->name)) {
+                    found_as = 1;
+                    break;
+                }
+            }
+
+            if (!found_as) {
+                avahi_server_set_errno(s, AVAHI_ERR_NOT_FOUND);
+                return NULL;
+            }
+            if ((l = avahi_rdata_serialize(r, rdata, sizeof(rdata))) == (size_t) -1) {
+                avahi_server_set_errno(s, AVAHI_ERR_FAILURE);
+                return NULL;
+            }
+            ret = DNSServiceUpdateRecord(as->client,
+                                         NULL,
+                                         0,
+                                         l,
+                                         rdata,
+                                         r->ttl);
+            if (ret != kDNSServiceErr_NoError) {
+                avahi_server_set_errno(s, AVAHI_ERR_FAILURE);
+            }
+            return NULL;
+#else
             avahi_server_set_errno(s, AVAHI_ERR_NOT_FOUND);
             return NULL;
+#endif
         }
 
         /* Update the entry */
@@ -248,6 +478,36 @@
 
         /* Announce our changes when needed */
         if (!avahi_record_equal_no_ttl(old_record, r) && (!g || g->state != AVAHI_ENTRY_GROUP_UNCOMMITED)) {
+#ifdef HAVE_BONJOUR
+            DNSServiceErrorType ret;
+            uint16_t rlen;
+            uint8_t rdata[AVAHI_DNS_RDATA_MAX];
+            size_t l;
+
+            if (!g->record_connection) {
+                if (DNSServiceCreateConnection(&g->record_connection) != kDNSServiceErr_NoError) {
+                    avahi_entry_free(s, e);
+                    avahi_server_set_errno(s, AVAHI_ERR_FAILURE);
+                    return NULL;
+                }
+            }
+            if ((l = avahi_rdata_serialize(r, rdata, sizeof(rdata))) == (size_t) -1) {
+                avahi_entry_free(s, e);
+                avahi_server_set_errno(s, AVAHI_ERR_FAILURE);
+                return NULL;
+            }
+            ret = DNSServiceUpdateRecord(g->record_connection,
+                                         e->recordref,
+                                         0,
+                                         l,
+                                         rdata,
+                                         r->ttl);
+            if (ret != kDNSServiceErr_NoError) {
+                avahi_entry_free(s, e);
+                avahi_server_set_errno(s, AVAHI_ERR_FAILURE);
+                return NULL;
+            }
+#else
 
             /* Remove the old entry from all caches, if needed */
             if (!(e->flags & AVAHI_PUBLISH_UNIQUE))
@@ -255,6 +515,7 @@
 
             /* Reannounce our updated entry */
             avahi_reannounce_entry(s, e);
+#endif
         }
 
         /* If we were the first entry in the list, we need to update the key */
@@ -265,6 +526,14 @@
 
     } else {
         AvahiEntry *t;
+#ifdef HAVE_BONJOUR
+        DNSServiceErrorType ret;
+        DNSServiceFlags bflags;
+        uint16_t rlen;
+        uint8_t rdata[AVAHI_DNS_RDATA_MAX];
+        size_t l;
+        char *record_name;
+#endif
 
         /* Add a new record */
     
@@ -299,7 +568,69 @@
         if (g)
             AVAHI_LLIST_PREPEND(AvahiEntry, by_group, g->entries, e); 
         
+#ifdef HAVE_BONJOUR
+        e->recordref = NULL; 
+        if (!g->record_connection) {
+            if (DNSServiceCreateConnection(&g->record_connection) != kDNSServiceErr_NoError) {
+                avahi_entry_free(s, e);
+                avahi_server_set_errno(s, AVAHI_ERR_FAILURE);
+                return NULL;
+            }
+        }
+        bflags = 0;
+        if (flags & AVAHI_PUBLISH_ALLOW_MULTIPLE)
+            bflags |= kDNSServiceFlagsShared;
+        else
+            bflags |= kDNSServiceFlagsUnique;
+
+        switch (r->key->type) {
+            case AVAHI_DNS_TYPE_A:
+            case AVAHI_DNS_TYPE_AAAA:
+                record_name = avahi_strdup(r->key->name);
+                break;
+            default:
+                record_name = avahi_malloc(strlen(r->key->name) + strlen(s->host_name_fqdn) + 2);
+                strcpy(record_name, r->key->name);
+                strcat(record_name, ".");
+                strcat(record_name, s->host_name_fqdn);
+                break;
+        }
+
+        if ((l = avahi_rdata_serialize(r, rdata, sizeof(rdata))) == (size_t) -1) {
+            avahi_entry_free(s, e);
+            avahi_server_set_errno(s, AVAHI_ERR_FAILURE);
+            return NULL;
+        }
+
+        ret = DNSServiceRegisterRecord(g->record_connection,
+                  &e->recordref,
+                  bflags,
+                  interface == AVAHI_IF_UNSPEC ? 
+                      kDNSServiceInterfaceIndexAny :
+                      interface,
+                  record_name,
+                  r->key->type,
+                  r->key->clazz,
+                  l,
+                  rdata,
+                  r->ttl,
+                  register_record_reply,
+                  e);
+        if (ret == kDNSServiceErr_NoError) {
+            ret = DNSServiceProcessResult(g->record_connection);
+            if (ret != kDNSServiceErr_NoError || e->recordref == NULL) {
+                avahi_entry_free(s, e);
+                return NULL;
+            }
+        } else {
+            avahi_entry_free(s, e);
+            avahi_server_set_errno(s, AVAHI_ERR_FAILURE);
+            return NULL;
+        }
+        avahi_free(record_name);
+#else
         avahi_announce_entry(s, e);
+#endif
     }
 
     return e;
@@ -575,7 +906,10 @@
     AvahiRecord *r = NULL;
     int ret = AVAHI_OK;
     AvahiEntry *srv_entry = NULL, *txt_entry = NULL, *ptr_entry = NULL, *enum_entry = NULL;
-    
+#ifdef HAVE_BONJOUR
+    AvahiService *as;
+#endif
+ 
     assert(s);
     assert(type);
     assert(name);
@@ -595,6 +929,36 @@
     if (!domain)
         domain = s->domain_name;
 
+#ifdef HAVE_BONJOUR
+    as = avahi_new (AvahiService, 1);
+    as->server = s;
+    as->group = g;
+    as->dead = 0;
+    as->flags = flags;
+    as->interface = interface;
+    as->protocol = protocol;
+    as->name = avahi_strdup(name);
+    as->type = avahi_strdup(type);
+    as->domain = avahi_strdup(domain);
+    as->host = avahi_strdup(host);
+    as->port = port;
+    as->watch = NULL;
+    as->client = NULL;
+    as->txtlen = avahi_string_list_serialize(strlst, NULL, 0);
+    if (as->txtlen > 0) {
+        as->txtrecord = avahi_new(uint8_t, as->txtlen);
+        if (as->txtrecord == NULL) {
+            as->txtlen = 0;
+            ret = avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
+            goto fail;
+        }
+        avahi_string_list_serialize(strlst, as->txtrecord, as->txtlen);
+    } else
+        as->txtrecord = NULL;
+
+    AVAHI_LLIST_PREPEND(AvahiService, services, s->services, as);
+    AVAHI_LLIST_PREPEND(AvahiService, services, g->services, as);
+#else
     if (!host)
         host = s->host_name_fqdn;
 
@@ -659,6 +1023,7 @@
         ret = avahi_server_errno(s);
         goto fail;
     }
+#endif
 
 fail:
     if (ret != AVAHI_OK && !(flags & AVAHI_PUBLISH_UPDATE)) {
@@ -938,6 +1303,18 @@
     return e;
 }
 
+#ifdef HAVE_BONJOUR
+static void server_cleanup_time_event_callback(AVAHI_GCC_UNUSED AvahiTimeEvent *e, void* userdata) {
+    AvahiServer *s = userdata;
+    assert(s);
+
+    avahi_time_event_free(s->cleanup_time_event);
+    s->cleanup_time_event = NULL;
+    
+    avahi_cleanup_dead_entries(s);
+}
+#endif
+
 int avahi_server_add_dns_server_address(
     AvahiServer *s,
     AvahiSEntryGroup *g,
@@ -1005,7 +1382,11 @@
     if (g->state == state)
         return;
 
+#ifdef HAVE_BONJOUR
+    assert(state <= AVAHI_ENTRY_GROUP_FAILURE);
+#else
     assert(state <= AVAHI_ENTRY_GROUP_COLLISION);
+#endif
 
     if (g->state == AVAHI_ENTRY_GROUP_ESTABLISHED) {
 
@@ -1050,6 +1431,10 @@
     g->register_time.tv_sec = 0;
     g->register_time.tv_usec = 0;
     AVAHI_LLIST_HEAD_INIT(AvahiEntry, g->entries);
+#ifdef HAVE_BONJOUR
+    AVAHI_LLIST_HEAD_INIT(AvahiService, g->services);
+    g->record_connection = NULL;
+#endif
 
     AVAHI_LLIST_PREPEND(AvahiSEntryGroup, groups, s->groups, g);
     return g;
@@ -1057,16 +1442,26 @@
 
 void avahi_s_entry_group_free(AvahiSEntryGroup *g) {
     AvahiEntry *e;
+#ifdef HAVE_BONJOUR
+    AvahiService *s;
+#endif
     
     assert(g);
     assert(g->server);
 
     for (e = g->entries; e; e = e->by_group_next) {
         if (!e->dead) {
+#ifndef HAVE_BONJOUR
             avahi_goodbye_entry(g->server, e, 1, 1);
+#endif
             e->dead = 1;
         }
     }
+#ifdef HAVE_BONJOUR
+    for (s = g->services; s; s = s->services_next) {
+        s->dead = 1;
+    }
+#endif
 
     if (g->register_time_event) {
         avahi_time_event_free(g->register_time_event);
@@ -1077,9 +1472,17 @@
     
     g->server->need_group_cleanup = 1;
     g->server->need_entry_cleanup = 1;
+#ifdef HAVE_BONJOUR
+    g->server->need_service_cleanup = 1;
+    if (!g->server->cleanup_time_event)
+        g->server->cleanup_time_event = avahi_time_event_new(g->server->time_event_queue, NULL, server_cleanup_time_event_callback, g->server);
+#endif
 }
 
 static void entry_group_commit_real(AvahiSEntryGroup *g) {
+#ifdef HAVE_BONJOUR
+    AvahiService *s;
+#endif
     assert(g);
 
     gettimeofday(&g->register_time, NULL);
@@ -1089,8 +1492,15 @@
     if (g->dead)
         return;
 
+#ifdef HAVE_BONJOUR
+    assert(g->server);
+    for (s = g->services; s; s = s->services_next)
+        if (!s->dead)
+            avahi_register_service(g->server, s);
+#else
     avahi_announce_group(g->server, g);
     avahi_s_entry_group_check_probed(g, 0);
+#endif
 }
 
 static void entry_group_register_time_event_callback(AVAHI_GCC_UNUSED AvahiTimeEvent *e, void* userdata) {
@@ -1143,16 +1553,29 @@
 
 void avahi_s_entry_group_reset(AvahiSEntryGroup *g) {
     AvahiEntry *e;
+#ifdef HAVE_BONJOUR
+    AvahiService *s;
+#endif
     assert(g);
     
     for (e = g->entries; e; e = e->by_group_next) {
         if (!e->dead) {
+#ifndef HAVE_BONJOUR
             avahi_goodbye_entry(g->server, e, 1, 1);
+#endif
             e->dead = 1;
         }
     }
     g->server->need_entry_cleanup = 1;
 
+#ifdef HAVE_BONJOUR
+    for (s = g->services; s; s = s->services_next) {
+        s->dead = 1;
+    }
+    g->server->need_service_cleanup = 1;
+    if (!g->server->cleanup_time_event)
+        g->server->cleanup_time_event = avahi_time_event_new(g->server->time_event_queue, NULL, server_cleanup_time_event_callback, g->server);
+#endif
     g->n_probing = 0;

     avahi_s_entry_group_change_state(g, AVAHI_ENTRY_GROUP_UNCOMMITED);
@@ -1195,12 +1618,23 @@
 
 int avahi_s_entry_group_is_empty(AvahiSEntryGroup *g) {
     AvahiEntry *e;
+#ifdef HAVE_BONJOUR
+    AvahiService *s;
+#endif
+
     assert(g);
 
+#ifdef HAVE_BONJOUR
+    for (s = g->services; s; s = s->services_next)
+        if (!s->dead)
+            return 0;
+#else
     /* Look for an entry that is not dead */
     for (e = g->entries; e; e = e->by_group_next)
         if (!e->dead)
             return 0;
+#endif
 
     return 1;
 }
+