Source: Desktop consolidation

Upstream promotion status: unknown

--- /usr/tmp/clean/avahi-0.6.28/avahi-core/entry.c	2010-08-26 01:51:38.985153000 +0100

+++ avahi-0.6.28/avahi-core/entry.c	2011-01-20 12:01:24.322248863 +0000

@@ -50,6 +50,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);

@@ -69,13 +96,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 && (as->group->services != NULL))

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

@@ -102,6 +262,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);

@@ -139,6 +308,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);

@@ -245,8 +429,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 */

@@ -256,6 +486,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))

@@ -263,6 +523,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 */

@@ -273,6 +534,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 */

@@ -307,7 +576,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;

@@ -583,6 +914,9 @@

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

@@ -603,6 +937,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;

@@ -667,6 +1031,7 @@

         ret = avahi_server_errno(s);

         goto fail;

     }

+#endif

 fail:

     if (ret != AVAHI_OK && !(flags & AVAHI_PUBLISH_UPDATE)) {

@@ -1013,7 +1378,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) {

@@ -1063,6 +1432,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;

@@ -1087,16 +1460,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);

@@ -1107,11 +1490,17 @@

     g->server->need_group_cleanup = 1;

     g->server->need_entry_cleanup = 1;

+#ifdef HAVE_BONJOUR

+    g->server->need_service_cleanup = 1;

+#endif

     schedule_cleanup(g->server);

 }

 static void entry_group_commit_real(AvahiSEntryGroup *g) {

+#ifdef HAVE_BONJOUR

+    AvahiService *s;

+#endif