X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=avahi-core%2Fserver.c;h=1511ac4f2932ca0df75393b29a3298f117d142a8;hb=a29887070855153ac64a3503e2f0004c2056f8e8;hp=6366dd835ebd04437654b16c9086978803d128a6;hpb=7ef880c32da573ba044cde87ae99a98a6038b7d1;p=catta

diff --git a/avahi-core/server.c b/avahi-core/server.c
index 6366dd8..1511ac4 100644
--- a/avahi-core/server.c
+++ b/avahi-core/server.c
@@ -35,6 +35,8 @@
 #include "socket.h"
 #include "subscribe.h"
 
+#define AVAHI_HOST_RR_HOLDOFF_MSEC 1000
+
 static void free_entry(AvahiServer*s, AvahiEntry *e) {
     AvahiEntry *t;
 
@@ -102,48 +104,61 @@ static void cleanup_dead(AvahiServer *s) {
     }
 }
 
-static void add_aux_records(AvahiServer *s, AvahiInterface *i, const gchar *name, guint16 type, gboolean unicast_response) {
+static void enum_aux_records(AvahiServer *s, AvahiInterface *i, const gchar *name, guint16 type, void (*callback)(AvahiServer *s, AvahiRecord *r, gboolean flush_cache, gpointer userdata), gpointer userdata) {
     AvahiKey *k;
+    AvahiEntry *e;
 
     g_assert(s);
     g_assert(i);
     g_assert(name);
+    g_assert(callback);
+
+    g_assert(type != AVAHI_DNS_TYPE_ANY);
 
     k = avahi_key_new(name, AVAHI_DNS_CLASS_IN, type);
-    avahi_server_prepare_matching_responses(s, i, k, unicast_response);
+
+    for (e = g_hash_table_lookup(s->entries_by_key, k); e; e = e->by_key_next)
+        if (!e->dead && avahi_entry_registered(s, e, i)) 
+            callback(s, e->record, e->flags & AVAHI_ENTRY_UNIQUE, userdata);
+
     avahi_key_unref(k);
 }
 
-void avahi_server_prepare_response(AvahiServer *s, AvahiInterface *i, AvahiEntry *e, gboolean unicast_response) {
+void avahi_server_enumerate_aux_records(AvahiServer *s, AvahiInterface *i, AvahiRecord *r, void (*callback)(AvahiServer *s, AvahiRecord *r, gboolean flush_cache, gpointer userdata), gpointer userdata) {
     g_assert(s);
     g_assert(i);
-    g_assert(e);
-
-    /* Append a record to a packet and all the records referred by it */
-
-    avahi_record_list_push(s->record_list, e->record, e->flags & AVAHI_ENTRY_UNIQUE, unicast_response);
+    g_assert(r);
+    g_assert(callback);
     
-    if (e->record->key->class == AVAHI_DNS_CLASS_IN) {
-        if (e->record->key->type == AVAHI_DNS_TYPE_PTR) {
-            add_aux_records(s, i, e->record->data.ptr.name, AVAHI_DNS_TYPE_SRV, unicast_response);
-            add_aux_records(s, i, e->record->data.ptr.name, AVAHI_DNS_TYPE_TXT, unicast_response);
-        } else if (e->record->key->type == AVAHI_DNS_TYPE_SRV) {
-            add_aux_records(s, i, e->record->data.srv.name, AVAHI_DNS_TYPE_A, unicast_response);
-            add_aux_records(s, i, e->record->data.srv.name, AVAHI_DNS_TYPE_AAAA, unicast_response);
+    if (r->key->class == AVAHI_DNS_CLASS_IN) {
+        if (r->key->type == AVAHI_DNS_TYPE_PTR) {
+            enum_aux_records(s, i, r->data.ptr.name, AVAHI_DNS_TYPE_SRV, callback, userdata);
+            enum_aux_records(s, i, r->data.ptr.name, AVAHI_DNS_TYPE_TXT, callback, userdata);
+        } else if (r->key->type == AVAHI_DNS_TYPE_SRV) {
+            enum_aux_records(s, i, r->data.srv.name, AVAHI_DNS_TYPE_A, callback, userdata);
+            enum_aux_records(s, i, r->data.srv.name, AVAHI_DNS_TYPE_AAAA, callback, userdata);
         }
     }
 }
 
+void avahi_server_prepare_response(AvahiServer *s, AvahiInterface *i, AvahiEntry *e, gboolean unicast_response, gboolean auxiliary) {
+    g_assert(s);
+    g_assert(i);
+    g_assert(e);
+
+    avahi_record_list_push(s->record_list, e->record, e->flags & AVAHI_ENTRY_UNIQUE, unicast_response, auxiliary);
+}
+
 void avahi_server_prepare_matching_responses(AvahiServer *s, AvahiInterface *i, AvahiKey *k, gboolean unicast_response) {
     AvahiEntry *e;
-    gchar *txt;
+/*     gchar *txt; */
     
     g_assert(s);
     g_assert(i);
     g_assert(k);
 
-    g_message("Posting responses matching [%s]", txt = avahi_key_to_string(k));
-    g_free(txt);
+/*     g_message("Posting responses matching [%s]", txt = avahi_key_to_string(k)); */
+/*     g_free(txt); */
 
     if (avahi_key_is_pattern(k)) {
 
@@ -151,7 +166,7 @@ void avahi_server_prepare_matching_responses(AvahiServer *s, AvahiInterface *i,
         
         for (e = s->entries; e; e = e->entries_next)
             if (!e->dead && avahi_key_pattern_match(k, e->record->key) && avahi_entry_registered(s, e, i))
-                avahi_server_prepare_response(s, i, e, unicast_response);
+                avahi_server_prepare_response(s, i, e, unicast_response, FALSE);
 
     } else {
 
@@ -159,7 +174,7 @@ void avahi_server_prepare_matching_responses(AvahiServer *s, AvahiInterface *i,
         
         for (e = g_hash_table_lookup(s->entries_by_key, k); e; e = e->by_key_next)
             if (!e->dead && avahi_entry_registered(s, e, i))
-                avahi_server_prepare_response(s, i, e, unicast_response);
+                avahi_server_prepare_response(s, i, e, unicast_response, FALSE);
     }
 }
 
@@ -245,7 +260,7 @@ static gboolean handle_conflict(AvahiServer *s, AvahiInterface *i, AvahiRecord *
 
     t = avahi_record_to_string(record);
 
-    g_message("CHECKING FOR CONFLICT: [%s]", t);  
+/*     g_message("CHECKING FOR CONFLICT: [%s]", t);   */
 
     for (e = g_hash_table_lookup(s->entries_by_key, record->key); e; e = n) {
         n = e->by_key_next;
@@ -264,7 +279,7 @@ static gboolean handle_conflict(AvahiServer *s, AvahiInterface *i, AvahiRecord *
                 if (record->ttl <= e->record->ttl/2) {
                     /* Refresh */
                     g_message("Recieved record with bad TTL [%s]. Refreshing.", t);
-                    avahi_interface_post_response(i, e->record, FALSE, TRUE, NULL);
+                    avahi_interface_post_response(i, e->record, FALSE, NULL, TRUE);
                     valid = FALSE;
                 }
                 
@@ -312,6 +327,23 @@ static gboolean handle_conflict(AvahiServer *s, AvahiInterface *i, AvahiRecord *
     return valid;
 }
 
+static void append_aux_callback(AvahiServer *s, AvahiRecord *r, gboolean flush_cache, gpointer userdata) {
+    gboolean *unicast_response = userdata;
+
+    g_assert(s);
+    g_assert(r);
+    g_assert(unicast_response);
+    
+    avahi_record_list_push(s->record_list, r, flush_cache, *unicast_response, TRUE);
+}
+
+static void append_aux_records_to_list(AvahiServer *s, AvahiInterface *i, AvahiRecord *r, gboolean unicast_response) {
+    g_assert(s);
+    g_assert(r);
+
+    avahi_server_enumerate_aux_records(s, i, r, append_aux_callback, &unicast_response);
+}
+
 void avahi_server_generate_response(AvahiServer *s, AvahiInterface *i, AvahiDnsPacket *p, const AvahiAddress *a, guint16 port, gboolean legacy_unicast) {
 
     g_assert(s);
@@ -324,7 +356,9 @@ void avahi_server_generate_response(AvahiServer *s, AvahiInterface *i, AvahiDnsP
 
         reply = avahi_dns_packet_new_reply(p, 512 /* unicast DNS maximum packet size is 512 */ , TRUE, TRUE);
         
-        while ((r = avahi_record_list_pop(s->record_list, NULL, NULL))) {
+        while ((r = avahi_record_list_next(s->record_list, NULL, NULL, NULL))) {
+
+            append_aux_records_to_list(s, i, r, FALSE);
             
             if (avahi_dns_packet_append_record(reply, r, FALSE, 10))
                 avahi_dns_packet_inc_field(reply, AVAHI_DNS_FIELD_ANCOUNT);
@@ -343,14 +377,21 @@ void avahi_server_generate_response(AvahiServer *s, AvahiInterface *i, AvahiDnsP
         avahi_dns_packet_free(reply);
 
     } else {
-        gboolean unicast_response, flush_cache;
+        gboolean unicast_response, flush_cache, auxiliary;
         AvahiDnsPacket *reply = NULL;
         AvahiRecord *r;
+
+        /* In case the query packet was truncated never respond
+        immediately, because known answer suppression records might be
+        contained in later packets */
+        gboolean tc = p && !!(avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_FLAGS) & AVAHI_DNS_FLAG_TC);
         
-        while ((r = avahi_record_list_pop(s->record_list, &flush_cache, &unicast_response))) {
+        while ((r = avahi_record_list_next(s->record_list, &flush_cache, &unicast_response, &auxiliary))) {
+                        
+            if (!avahi_interface_post_response(i, r, flush_cache, a, !tc && flush_cache && !auxiliary) && unicast_response) {
 
-            if (!avahi_interface_post_response(i, r, flush_cache, FALSE, a) && unicast_response) {
-            
+                append_aux_records_to_list(s, i, r, unicast_response);
+                
                 /* Due to some reasons the record has not been scheduled.
                  * The client requested an unicast response in that
                  * case. Therefore we prepare such a response */
@@ -373,10 +414,25 @@ void avahi_server_generate_response(AvahiServer *s, AvahiInterface *i, AvahiDnsP
                     }
 
                     if (avahi_dns_packet_get_field(reply, AVAHI_DNS_FIELD_ANCOUNT) == 0) {
-                        gchar *t = avahi_record_to_string(r);
-                        g_warning("Record [%s] too large, doesn't fit in any packet!", t);
-                        g_free(t);
-                        break;
+                        guint size;
+
+                        /* The record is too large for one packet, so create a larger packet */
+
+                        avahi_dns_packet_free(reply);
+                        size = avahi_record_get_estimate_size(r) + AVAHI_DNS_PACKET_HEADER_SIZE;
+                        if (size > AVAHI_DNS_PACKET_MAX_SIZE)
+                            size = AVAHI_DNS_PACKET_MAX_SIZE;
+                        reply = avahi_dns_packet_new_reply(p, size, FALSE, TRUE);
+
+                        if (!avahi_dns_packet_append_record(reply, r, flush_cache, 0)) {
+                            avahi_dns_packet_free(reply);
+                            
+                            gchar *t = avahi_record_to_string(r);
+                            g_warning("Record [%s] too large, doesn't fit in any packet!", t);
+                            g_free(t);
+                            break;
+                        } else
+                            avahi_dns_packet_inc_field(reply, AVAHI_DNS_FIELD_ANCOUNT);
                     }
 
                     /* Appending the record didn't succeeed, so let's send this packet, and create a new one */
@@ -395,6 +451,8 @@ void avahi_server_generate_response(AvahiServer *s, AvahiInterface *i, AvahiDnsP
             avahi_dns_packet_free(reply);
         }
     }
+
+    avahi_record_list_flush(s->record_list);
 }
 
 static void handle_query(AvahiServer *s, AvahiDnsPacket *p, AvahiInterface *i, const AvahiAddress *a, guint16 port, gboolean legacy_unicast) {
@@ -417,9 +475,9 @@ static void handle_query(AvahiServer *s, AvahiDnsPacket *p, AvahiInterface *i, c
         if (!(key = avahi_dns_packet_consume_key(p, &unicast_response))) {
             g_warning("Packet too short (1)");
             goto fail;
-       }
+        }
 
-        avahi_packet_scheduler_incoming_query(i->scheduler, key);
+        avahi_query_scheduler_incoming(i->query_scheduler, key);
         avahi_server_prepare_matching_responses(s, i, key, unicast_response);
         avahi_key_unref(key);
     }
@@ -435,7 +493,7 @@ static void handle_query(AvahiServer *s, AvahiDnsPacket *p, AvahiInterface *i, c
         }
 
         if (handle_conflict(s, i, record, unique, a)) {
-            avahi_packet_scheduler_incoming_known_answer(i->scheduler, record, a);
+            avahi_response_scheduler_suppress(i->response_scheduler, record, a);
             avahi_record_list_drop(s->record_list, record);
         }
         
@@ -482,7 +540,7 @@ static void handle_response(AvahiServer *s, AvahiDnsPacket *p, AvahiInterface *i
              avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ARCOUNT); n > 0; n--) {
         AvahiRecord *record;
         gboolean cache_flush = FALSE;
-        gchar *txt;
+/*         gchar *txt; */
         
         if (!(record = avahi_dns_packet_consume_record(p, &cache_flush))) {
             g_warning("Packet too short (4)");
@@ -491,12 +549,12 @@ static void handle_response(AvahiServer *s, AvahiDnsPacket *p, AvahiInterface *i
 
         if (record->key->type != AVAHI_DNS_TYPE_ANY) {
 
-            g_message("Handling response: %s", txt = avahi_record_to_string(record));
-            g_free(txt);
+/*             g_message("Handling response: %s", txt = avahi_record_to_string(record)); */
+/*             g_free(txt); */
             
             if (handle_conflict(s, i, record, cache_flush, a)) {
                 avahi_cache_update(i->cache, record, cache_flush, a);
-                avahi_packet_scheduler_incoming_response(i->scheduler, record, cache_flush);
+                avahi_response_scheduler_incoming(i->response_scheduler, record, cache_flush);
             }
         }
             
@@ -520,7 +578,7 @@ static void dispatch_packet(AvahiServer *s, AvahiDnsPacket *p, struct sockaddr *
         return;
     }
 
-    g_message("new packet recieved on interface '%s.%i'.", i->hardware->name, i->protocol);
+/*     g_message("new packet recieved on interface '%s.%i'.", i->hardware->name, i->protocol); */
 
     if (sa->sa_family == AF_INET6) {
         static const guint8 ipv4_in_ipv6[] = {
@@ -564,7 +622,7 @@ static void dispatch_packet(AvahiServer *s, AvahiDnsPacket *p, struct sockaddr *
 
         handle_query(s, p, i, &a, port, legacy_unicast);
         
-        g_message("Handled query");
+/*         g_message("Handled query"); */
     } else {
 
         if (port != AVAHI_MDNS_PORT) {
@@ -574,7 +632,7 @@ static void dispatch_packet(AvahiServer *s, AvahiDnsPacket *p, struct sockaddr *
 
         if (ttl != 255) {
             g_warning("Recieved response with invalid TTL %u on interface '%s.%i'.", ttl, i->hardware->name, i->protocol);
-            if (!s->ignore_bad_ttl)
+            if (s->config.check_response_ttl)
                 return;
         }
 
@@ -586,7 +644,7 @@ static void dispatch_packet(AvahiServer *s, AvahiDnsPacket *p, struct sockaddr *
         }
 
         handle_response(s, p, i, &a);
-        g_message("Handled response");
+/*         g_message("Handled response"); */
     }
 }
 
@@ -594,7 +652,7 @@ static void work(AvahiServer *s) {
     struct sockaddr_in6 sa6;
     struct sockaddr_in sa;
     AvahiDnsPacket *p;
-    gint iface = -1;
+    gint iface = 0;
     guint8 ttl;
         
     g_assert(s);
@@ -645,23 +703,92 @@ static gboolean dispatch_func(GSource *source, GSourceFunc callback, gpointer us
     return TRUE;
 }
 
-static void add_default_entries(AvahiServer *s) {
+static void server_set_state(AvahiServer *s, AvahiServerState state) {
+    g_assert(s);
+
+    if (s->state == state)
+        return;
+    
+    s->state = state;
+
+    if (s->callback)
+        s->callback(s, state, s->userdata);
+}
+
+static void withdraw_host_rrs(AvahiServer *s) {
+    g_assert(s);
+
+    if (s->hinfo_entry_group) {
+        avahi_entry_group_free(s->hinfo_entry_group);
+        s->hinfo_entry_group = NULL;
+    }
+
+    if (s->browse_domain_entry_group) {
+        avahi_entry_group_free(s->browse_domain_entry_group);
+        s->browse_domain_entry_group = NULL;
+    }
+
+    avahi_update_host_rrs(s->monitor, TRUE);
+    s->n_host_rr_pending = 0;
+}
+
+void avahi_server_decrease_host_rr_pending(AvahiServer *s) {
+    g_assert(s);
+    
+    g_assert(s->n_host_rr_pending > 0);
+
+    if (--s->n_host_rr_pending == 0)
+        server_set_state(s, AVAHI_SERVER_RUNNING);
+}
+
+void avahi_server_increase_host_rr_pending(AvahiServer *s) {
+    g_assert(s);
+
+    s->n_host_rr_pending ++;
+}
+
+void avahi_host_rr_entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, void *userdata) {
+    g_assert(s);
+    g_assert(g);
+
+    if (state == AVAHI_ENTRY_GROUP_REGISTERING &&
+        s->state == AVAHI_SERVER_REGISTERING)
+        avahi_server_increase_host_rr_pending(s);
+    else if (state == AVAHI_ENTRY_GROUP_COLLISION &&
+        (s->state == AVAHI_SERVER_REGISTERING || s->state == AVAHI_SERVER_RUNNING)) {
+        withdraw_host_rrs(s);
+        server_set_state(s, AVAHI_SERVER_COLLISION);
+    } else if (state == AVAHI_ENTRY_GROUP_ESTABLISHED &&
+               s->state == AVAHI_SERVER_REGISTERING)
+        avahi_server_decrease_host_rr_pending(s);
+}
+
+static void register_hinfo(AvahiServer *s) {
     struct utsname utsname;
-    AvahiAddress a;
     AvahiRecord *r;
     
     g_assert(s);
-
-    return ;
+    
+    if (!s->config.register_hinfo || s->hinfo_entry_group)
+        return;
+    
+    s->hinfo_entry_group = avahi_entry_group_new(s, avahi_host_rr_entry_group_callback, NULL);
     
     /* Fill in HINFO rr */
     r = avahi_record_new_full(s->host_name_fqdn, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_HINFO);
     uname(&utsname);
     r->data.hinfo.cpu = g_strdup(g_strup(utsname.machine));
     r->data.hinfo.os = g_strdup(g_strup(utsname.sysname));
-    avahi_server_add(s, NULL, 0, AF_UNSPEC, AVAHI_ENTRY_UNIQUE, r);
+    avahi_server_add(s, s->hinfo_entry_group, 0, AF_UNSPEC, AVAHI_ENTRY_UNIQUE, r);
     avahi_record_unref(r);
 
+    avahi_entry_group_commit(s->hinfo_entry_group);
+}
+
+static void register_localhost(AvahiServer *s) {
+    AvahiAddress a;
+    g_assert(s);
+    
     /* Add localhost entries */
     avahi_address_parse("127.0.0.1", AF_INET, &a);
     avahi_server_add_address(s, NULL, 0, AF_UNSPEC, AVAHI_ENTRY_NOPROBE|AVAHI_ENTRY_NOANNOUNCE, "localhost", &a);
@@ -670,7 +797,96 @@ static void add_default_entries(AvahiServer *s) {
     avahi_server_add_address(s, NULL, 0, AF_UNSPEC, AVAHI_ENTRY_NOPROBE|AVAHI_ENTRY_NOANNOUNCE, "ip6-localhost", &a);
 }
 
-AvahiServer *avahi_server_new(GMainContext *c) {
+static void register_browse_domain(AvahiServer *s) {
+    g_assert(s);
+
+    if (!s->config.announce_domain || s->browse_domain_entry_group)
+        return;
+
+    s->browse_domain_entry_group = avahi_entry_group_new(s, NULL, NULL);
+    avahi_server_add_ptr(s, s->browse_domain_entry_group, 0, AF_UNSPEC, 0, "_browse._dns-sd._udp.local", s->domain_name);
+    avahi_entry_group_commit(s->browse_domain_entry_group);
+}
+
+static void register_stuff(AvahiServer *s) {
+    g_assert(s);
+
+    server_set_state(s, AVAHI_SERVER_REGISTERING);
+    register_hinfo(s);
+    register_browse_domain(s);
+    avahi_update_host_rrs(s->monitor, FALSE);
+
+    if (s->n_host_rr_pending == 0)
+        server_set_state(s, AVAHI_SERVER_RUNNING);
+}
+
+static void update_fqdn(AvahiServer *s) {
+    g_assert(s);
+    
+    g_assert(s->host_name);
+    g_assert(s->domain_name);
+
+    g_free(s->host_name_fqdn);
+    s->host_name_fqdn = g_strdup_printf("%s.%s", s->host_name, s->domain_name);
+}
+
+static void register_time_event_callback(AvahiTimeEvent *e, gpointer userdata) {
+    AvahiServer *s = userdata;
+    
+    g_assert(e);
+    g_assert(s);
+
+    g_assert(e == s->register_time_event);
+    avahi_time_event_queue_remove(s->time_event_queue, s->register_time_event);
+    s->register_time_event = NULL;
+
+    if (s->state == AVAHI_SERVER_SLEEPING)
+        register_stuff(s);
+}
+
+static void delayed_register_stuff(AvahiServer *s) {
+    GTimeVal tv;
+    
+    g_assert(s);
+
+    avahi_elapse_time(&tv, AVAHI_HOST_RR_HOLDOFF_MSEC, 0);
+
+    if (s->register_time_event)
+        avahi_time_event_queue_update(s->time_event_queue, s->register_time_event, &tv);
+    else
+        s->register_time_event = avahi_time_event_queue_add(s->time_event_queue, &tv, register_time_event_callback, s);
+}
+
+void avahi_server_set_host_name(AvahiServer *s, const gchar *host_name) {
+    g_assert(s);
+    g_assert(host_name);
+
+    server_set_state(s, AVAHI_SERVER_SLEEPING);
+    withdraw_host_rrs(s);
+
+    g_free(s->host_name);
+    s->host_name = host_name ? avahi_normalize_name(host_name) : avahi_get_host_name();
+    s->host_name[strcspn(s->host_name, ".")] = 0;
+    update_fqdn(s);
+
+    delayed_register_stuff(s);
+}
+
+void avahi_server_set_domain_name(AvahiServer *s, const gchar *domain_name) {
+    g_assert(s);
+    g_assert(domain_name);
+
+    server_set_state(s, AVAHI_SERVER_SLEEPING);
+    withdraw_host_rrs(s);
+
+    g_free(s->domain_name);
+    s->domain_name = domain_name ? avahi_normalize_name(domain_name) : g_strdup("local.");
+    update_fqdn(s);
+
+    delayed_register_stuff(s);
+}
+
+AvahiServer *avahi_server_new(GMainContext *c, const AvahiServerConfig *sc, AvahiServerCallback callback, gpointer userdata) {
     AvahiServer *s;
     
     static GSourceFuncs source_funcs = {
@@ -683,51 +899,34 @@ AvahiServer *avahi_server_new(GMainContext *c) {
     };
 
     s = g_new(AvahiServer, 1);
-
-    s->ignore_bad_ttl = FALSE;
+    s->n_host_rr_pending = 0;
     s->need_entry_cleanup = s->need_group_cleanup = FALSE;
+
+    if (sc)
+        avahi_server_config_copy(&s->config, sc);
+    else
+        avahi_server_config_init(&s->config);
     
-    s->fd_ipv4 = avahi_open_socket_ipv4();
-    s->fd_ipv6 = -1 /* avahi_open_socket_ipv6() */ ;
+    s->fd_ipv4 = s->config.use_ipv4 ? avahi_open_socket_ipv4() : -1;
+    s->fd_ipv6 = s->config.use_ipv6 ? avahi_open_socket_ipv6() : -1;
     
     if (s->fd_ipv6 < 0 && s->fd_ipv4 < 0) {
-        g_critical("Failed to create IP sockets.\n");
+        g_critical("Selected neither IPv6 nor IPv4 support, aborting.\n");
+        avahi_server_config_free(&s->config);
         g_free(s);
         return NULL;
     }
 
-    if (s->fd_ipv4 < 0)
+    if (s->fd_ipv4 < 0 && s->config.use_ipv4)
         g_message("Failed to create IPv4 socket, proceeding in IPv6 only mode");
-    else if (s->fd_ipv6 < 0)
+    else if (s->fd_ipv6 < 0 && s->config.use_ipv6)
         g_message("Failed to create IPv6 socket, proceeding in IPv4 only mode");
     
     if (c)
         g_main_context_ref(s->context = c);
     else
         s->context = g_main_context_default();
-    
-    AVAHI_LLIST_HEAD_INIT(AvahiEntry, s->entries);
-    s->entries_by_key = g_hash_table_new((GHashFunc) avahi_key_hash, (GEqualFunc) avahi_key_equal);
-    AVAHI_LLIST_HEAD_INIT(AvahiGroup, s->groups);
-
-    AVAHI_LLIST_HEAD_INIT(AvahiSubscription, s->subscriptions);
-    s->subscription_hashtable = g_hash_table_new((GHashFunc) avahi_key_hash, (GEqualFunc) avahi_key_equal);
 
-    /* Get host name */
-    s->host_name = avahi_get_host_name();
-    s->host_name[strcspn(s->host_name, ".")] = 0;
-
-    s->domain = avahi_normalize_name("local.");
-
-    s->host_name_fqdn = g_strdup_printf("%s.%s", s->host_name, s->domain);
-
-    s->record_list = avahi_record_list_new();
-
-    s->time_event_queue = avahi_time_event_queue_new(s->context, G_PRIORITY_DEFAULT+10); /* Slightly less priority than the FDs */
-    s->monitor = avahi_interface_monitor_new(s);
-    avahi_interface_monitor_sync(s->monitor);
-    add_default_entries(s);
-    
     /* Prepare IO source registration */
     s->source = g_source_new(&source_funcs, sizeof(GSource) + sizeof(AvahiServer*));
     *((AvahiServer**) (((guint8*) s->source) + sizeof(GSource))) = s;
@@ -743,7 +942,41 @@ AvahiServer *avahi_server_new(GMainContext *c) {
     g_source_add_poll(s->source, &s->pollfd_ipv6);
 
     g_source_attach(s->source, s->context);
+    
+    s->callback = callback;
+    s->userdata = userdata;
+    
+    AVAHI_LLIST_HEAD_INIT(AvahiEntry, s->entries);
+    s->entries_by_key = g_hash_table_new((GHashFunc) avahi_key_hash, (GEqualFunc) avahi_key_equal);
+    AVAHI_LLIST_HEAD_INIT(AvahiGroup, s->groups);
+
+    AVAHI_LLIST_HEAD_INIT(AvahiRecordResolver, s->record_resolvers);
+    s->record_resolver_hashtable = g_hash_table_new((GHashFunc) avahi_key_hash, (GEqualFunc) avahi_key_equal);
+    AVAHI_LLIST_HEAD_INIT(AvahiHostNameResolver, s->host_name_resolvers);
+
+    /* Get host name */
+    s->host_name = s->config.host_name ? avahi_normalize_name(s->config.host_name) : avahi_get_host_name();
+    s->host_name[strcspn(s->host_name, ".")] = 0;
+    s->domain_name = s->config.domain_name ? avahi_normalize_name(s->config.domain_name) : g_strdup("local.");
+    s->host_name_fqdn = NULL;
+    update_fqdn(s);
 
+    s->record_list = avahi_record_list_new();
+
+    s->time_event_queue = avahi_time_event_queue_new(s->context, G_PRIORITY_DEFAULT+10); /* Slightly less priority than the FDs */
+    s->register_time_event = NULL;
+    
+    s->state = AVAHI_SERVER_INVALID;
+
+    s->monitor = avahi_interface_monitor_new(s);
+    avahi_interface_monitor_sync(s->monitor);
+
+    register_localhost(s);
+
+    s->hinfo_entry_group = NULL;
+    s->browse_domain_entry_group = NULL;
+    register_stuff(s);
+    
     return s;
 }
 
@@ -758,12 +991,17 @@ void avahi_server_free(AvahiServer* s) {
     while (s->groups)
         free_group(s, s->groups);
 
-    while (s->subscriptions)
-        avahi_subscription_free(s->subscriptions);
-    g_hash_table_destroy(s->subscription_hashtable);
+    while (s->host_name_resolvers)
+        avahi_host_name_resolver_free(s->host_name_resolvers);
+    
+    while (s->record_resolvers)
+        avahi_record_resolver_free(s->record_resolvers);
+    g_hash_table_destroy(s->record_resolver_hashtable);
 
     g_hash_table_destroy(s->entries_by_key);
 
+    if (s->register_time_event)
+        avahi_time_event_queue_remove(s->time_event_queue, s->register_time_event);
     avahi_time_event_queue_free(s->time_event_queue);
 
     avahi_record_list_free(s->record_list);
@@ -774,13 +1012,15 @@ void avahi_server_free(AvahiServer* s) {
         close(s->fd_ipv6);
 
     g_free(s->host_name);
-    g_free(s->domain);
+    g_free(s->domain_name);
     g_free(s->host_name_fqdn);
 
     g_source_destroy(s->source);
     g_source_unref(s->source);
     g_main_context_unref(s->context);
 
+    avahi_server_config_free(&s->config);
+
     g_free(s);
 }
 
@@ -1026,7 +1266,7 @@ void avahi_server_add_service_strlst(
         while (domain[0] == '.')
             domain++;
     } else
-        domain = "local";
+        domain = s->domain_name;
 
     if (!host)
         host = s->host_name_fqdn;
@@ -1114,7 +1354,7 @@ void avahi_entry_group_change_state(AvahiEntryGroup *g, AvahiEntryGroupState sta
 
     if (g->state == state)
         return;
-    
+
     g->state = state;
     
     if (g->callback) {
@@ -1142,11 +1382,20 @@ AvahiEntryGroup *avahi_entry_group_new(AvahiServer *s, AvahiEntryGroupCallback c
 }
 
 void avahi_entry_group_free(AvahiEntryGroup *g) {
+    AvahiEntry *e;
+    
     g_assert(g);
     g_assert(g->server);
 
+    for (e = g->entries; e; e = e->by_group_next) {
+        avahi_goodbye_entry(g->server, e, TRUE);
+        e->dead = TRUE;
+    }
+
     g->dead = TRUE;
+    
     g->server->need_group_cleanup = TRUE;
+    g->server->need_entry_cleanup = TRUE;
 }
 
 void avahi_entry_group_commit(AvahiEntryGroup *g) {
@@ -1177,14 +1426,86 @@ AvahiEntryGroupState avahi_entry_group_get_state(AvahiEntryGroup *g) {
     return g->state;
 }
 
-const gchar* avahi_server_get_domain(AvahiServer *s) {
+void avahi_entry_group_set_data(AvahiEntryGroup *g, gpointer userdata) {
+    g_assert(g);
+
+    g->userdata = userdata;
+}
+
+gpointer avahi_entry_group_get_data(AvahiEntryGroup *g) {
+    g_assert(g);
+
+    return g->userdata;
+}
+
+const gchar* avahi_server_get_domain_name(AvahiServer *s) {
     g_assert(s);
 
-    return s->domain;
+    return s->domain_name;
 }
 
 const gchar* avahi_server_get_host_name(AvahiServer *s) {
     g_assert(s);
 
+    return s->host_name;
+}
+
+const gchar* avahi_server_get_host_name_fqdn(AvahiServer *s) {
+    g_assert(s);
+
     return s->host_name_fqdn;
 }
+
+gpointer avahi_server_get_data(AvahiServer *s) {
+    g_assert(s);
+
+    return s->userdata;
+}
+
+void avahi_server_set_data(AvahiServer *s, gpointer userdata) {
+    g_assert(s);
+
+    s->userdata = userdata;
+}
+
+AvahiServerState avhai_server_get_state(AvahiServer *s) {
+    g_assert(s);
+
+    return s->state;
+}
+
+AvahiServerConfig* avahi_server_config_init(AvahiServerConfig *c) {
+    g_assert(c);
+
+    memset(c, 0, sizeof(AvahiServerConfig));
+    c->register_hinfo = TRUE;
+    c->register_addresses = TRUE;
+    c->use_ipv6 = TRUE;
+    c->use_ipv4 = TRUE;
+    c->host_name = NULL;
+    c->domain_name = NULL;
+    c->check_response_ttl = TRUE;
+    c->announce_domain = TRUE;
+    c->use_iff_running = FALSE;
+    
+    return c;
+}
+
+void avahi_server_config_free(AvahiServerConfig *c) {
+    g_assert(c);
+
+    g_free(c->host_name);
+    g_free(c->domain_name);
+}
+
+AvahiServerConfig* avahi_server_config_copy(AvahiServerConfig *ret, const AvahiServerConfig *c) {
+    g_assert(ret);
+    g_assert(c);
+
+    *ret = *c;
+
+    ret->host_name = g_strdup(c->host_name);
+    ret->domain_name = g_strdup(c->domain_name);
+
+    return ret;
+}