add a real check for linux/netlink.h

[catta] / avahi-compat-libdns_sd / compat.c

diff --git a/avahi-compat-libdns_sd/compat.c b/avahi-compat-libdns_sd/compat.c
index 3e2eb9db187bc66ae1e9577f5bb2111d3061f400..fda5b59262f3b88d2e688b1874b96795d63700b8 100644 (file)
--- a/avahi-compat-libdns_sd/compat.c
+++ b/avahi-compat-libdns_sd/compat.c
@@ -99,6 +99,7 @@ static DNSServiceErrorType map_error(int error) {
         case AVAHI_ERR_INVALID_PORT:
         case AVAHI_ERR_INVALID_KEY:
         case AVAHI_ERR_INVALID_ADDRESS:
+        case AVAHI_ERR_INVALID_SERVICE_SUBTYPE:
             return kDNSServiceErr_BadParam;
 
 
@@ -145,6 +146,20 @@ static DNSServiceErrorType map_error(int error) {
     return kDNSServiceErr_Unknown;
 }
 
+static const char *add_trailing_dot(const char *s, char *buf, size_t buf_len) {
+    if (!s)
+        return NULL;
+
+    if (*s == 0)
+        return s;
+
+    if (s[strlen(s)-1] == '.')
+        return s;
+
+    snprintf(buf, buf_len, "%s.", s);
+    return buf;
+}
+
 static int read_command(int fd) {
     ssize_t r;
     char command;
@@ -415,11 +430,14 @@ static void service_browser_callback(
     void *userdata) {
 
     DNSServiceRef sdref = userdata;
-
+    char type_fixed[AVAHI_DOMAIN_NAME_MAX], domain_fixed[AVAHI_DOMAIN_NAME_MAX];
     assert(b);
     assert(sdref);
     assert(sdref->n_ref >= 1);
 
+    type = add_trailing_dot(type, type_fixed, sizeof(type_fixed));
+    domain  = add_trailing_dot(domain, domain_fixed, sizeof(domain_fixed));
+    
     switch (event) {
         case AVAHI_BROWSER_NEW:
             sdref->service_browser_callback(sdref, kDNSServiceFlagsAdd, interface, kDNSServiceErr_NoError, name, type, domain, sdref->context);
@@ -430,11 +448,7 @@ static void service_browser_callback(
             break;
 
         case AVAHI_BROWSER_FAILURE:
-            sdref->service_browser_callback(sdref, 0, interface, kDNSServiceErr_Unknown, NULL, NULL, NULL, sdref->context);
-            break;
-            
-        case AVAHI_BROWSER_NOT_FOUND:
-            sdref->service_browser_callback(sdref, 0, interface, kDNSServiceErr_NoSuchName, NULL, NULL, NULL, sdref->context);
+            sdref->service_browser_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), NULL, NULL, NULL, sdref->context);
             break;
             
         case AVAHI_BROWSER_CACHE_EXHAUSTED:
@@ -492,8 +506,10 @@ DNSServiceErrorType DNSSD_API DNSServiceBrowse(
     assert(domain);
     assert(callback);
 
-    if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0)
+    if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
+        AVAHI_WARN_UNSUPPORTED;
         return kDNSServiceErr_Unsupported;
+    }
 
     if (!(sdref = sdref_new()))
         return kDNSServiceErr_Unknown;
@@ -544,15 +560,18 @@ static void service_resolver_callback(
     void *userdata) {
 
     DNSServiceRef sdref = userdata;
+    char host_name_fixed[AVAHI_DOMAIN_NAME_MAX];
 
     assert(r);
     assert(sdref);
     assert(sdref->n_ref >= 1);
 
+    host_name = add_trailing_dot(host_name, host_name_fixed, sizeof(host_name_fixed));
+
     switch (event) {
         case AVAHI_RESOLVER_FOUND: {
 
-            char full_name[kDNSServiceMaxDomainName];
+            char full_name[AVAHI_DOMAIN_NAME_MAX];
             int ret;
             char *p = NULL;
             size_t l = 0;
@@ -560,8 +579,10 @@ static void service_resolver_callback(
             if ((p = avahi_new0(char, (l = avahi_string_list_serialize(txt, NULL, 0))+1)))
                 avahi_string_list_serialize(txt, p, l);
 
-            ret = avahi_service_name_snprint(full_name, sizeof(full_name), name, type, domain);
+            ret = avahi_service_name_join(full_name, sizeof(full_name), name, type, domain);
             assert(ret == AVAHI_OK);
+
+            strcat(full_name, ".");
             
             sdref->service_resolver_callback(sdref, 0, interface, kDNSServiceErr_NoError, full_name, host_name, htons(port), l, p, sdref->context);
 
@@ -569,13 +590,8 @@ static void service_resolver_callback(
             break;
         }
 
-        case AVAHI_RESOLVER_TIMEOUT:
-        case AVAHI_RESOLVER_NOT_FOUND:
-            sdref->service_resolver_callback(sdref, 0, interface, kDNSServiceErr_NoSuchName, NULL, NULL, 0, 0, NULL, sdref->context);
-            break;
-            
         case AVAHI_RESOLVER_FAILURE:
-            sdref->service_resolver_callback(sdref, 0, interface, kDNSServiceErr_Unknown, NULL, NULL, 0, 0, NULL, sdref->context);
+            sdref->service_resolver_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), NULL, NULL, 0, 0, NULL, sdref->context);
             
     }
 }
@@ -603,8 +619,10 @@ DNSServiceErrorType DNSSD_API DNSServiceResolve(
     assert(domain);
     assert(callback);
 
-    if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0)
+    if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
+        AVAHI_WARN_UNSUPPORTED;
         return kDNSServiceErr_Unsupported;
+    }
 
     if (!(sdref = sdref_new()))
         return kDNSServiceErr_Unknown;
@@ -652,7 +670,7 @@ int DNSSD_API DNSServiceConstructFullName (
     assert(regtype);
     assert(domain);
 
-    if (avahi_service_name_snprint(fullName, kDNSServiceMaxDomainName, service, regtype, domain) < 0)
+    if (avahi_service_name_join(fullName, kDNSServiceMaxDomainName, service, regtype, domain) < 0)
         return -1;
     
     return 0;
@@ -668,11 +686,14 @@ static void domain_browser_callback(
     void *userdata) {
 
     DNSServiceRef sdref = userdata;
+    static char domain_fixed[AVAHI_DOMAIN_NAME_MAX];
 
     assert(b);
     assert(sdref);
     assert(sdref->n_ref >= 1);
 
+    domain  = add_trailing_dot(domain, domain_fixed, sizeof(domain_fixed));
+
     switch (event) {
         case AVAHI_BROWSER_NEW:
             sdref->domain_browser_callback(sdref, kDNSServiceFlagsAdd, interface, kDNSServiceErr_NoError, domain, sdref->context);
@@ -683,11 +704,7 @@ static void domain_browser_callback(
             break;
 
         case AVAHI_BROWSER_FAILURE:
-            sdref->domain_browser_callback(sdref, 0, interface, kDNSServiceErr_Unknown, domain, sdref->context);
-            break;
-            
-        case AVAHI_BROWSER_NOT_FOUND:
-            sdref->domain_browser_callback(sdref, 0, interface, kDNSServiceErr_NoSuchName, domain, sdref->context);
+            sdref->domain_browser_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), domain, sdref->context);
             break;
             
         case AVAHI_BROWSER_CACHE_EXHAUSTED:
@@ -714,8 +731,10 @@ DNSServiceErrorType DNSSD_API DNSServiceEnumerateDomains(
     assert(callback);
 
     if (interface == kDNSServiceInterfaceIndexLocalOnly ||
-        (flags != kDNSServiceFlagsBrowseDomains &&  flags != kDNSServiceFlagsRegistrationDomains))
+        (flags != kDNSServiceFlagsBrowseDomains &&  flags != kDNSServiceFlagsRegistrationDomains)) {
+        AVAHI_WARN_UNSUPPORTED;
         return kDNSServiceErr_Unsupported;
+    }
 
     if (!(sdref = sdref_new()))
         return kDNSServiceErr_Unknown;
@@ -732,7 +751,7 @@ DNSServiceErrorType DNSSD_API DNSServiceEnumerateDomains(
 
     ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
     
-    if (!(sdref->domain_browser = avahi_domain_browser_new(sdref->client, ifindex, AVAHI_PROTO_UNSPEC, NULL,
+    if (!(sdref->domain_browser = avahi_domain_browser_new(sdref->client, ifindex, AVAHI_PROTO_UNSPEC, "local",
                                                            flags == kDNSServiceFlagsRegistrationDomains ? AVAHI_DOMAIN_BROWSER_REGISTER : AVAHI_DOMAIN_BROWSER_BROWSE,
                                                            0, domain_browser_callback, sdref))) {
         ret = map_error(avahi_client_errno(sdref->client));
@@ -753,37 +772,63 @@ finish:
 }
 
 static void reg_report_error(DNSServiceRef sdref, DNSServiceErrorType error) {
+    char regtype_fixed[AVAHI_DOMAIN_NAME_MAX], domain_fixed[AVAHI_DOMAIN_NAME_MAX];
+    const char *regtype, *domain;
     assert(sdref);
     assert(sdref->n_ref >= 1);
 
     assert(sdref->service_register_callback);
 
+    regtype = add_trailing_dot(sdref->service_regtype, regtype_fixed, sizeof(regtype_fixed));
+    domain = add_trailing_dot(sdref->service_domain, domain_fixed, sizeof(domain_fixed));
+    
     sdref->service_register_callback(
         sdref, 0, error,
         sdref->service_name_chosen ? sdref->service_name_chosen : sdref->service_name,
-        sdref->service_regtype,
-        sdref->service_domain,
+        regtype,
+        domain,
         sdref->context);
 }
 
 static int reg_create_service(DNSServiceRef sdref) {
     int ret;
+    const char *real_type;
+    
     assert(sdref);
     assert(sdref->n_ref >= 1);
 
+    real_type = avahi_get_type_from_subtype(sdref->service_regtype);
+    
     if ((ret = avahi_entry_group_add_service_strlst(
         sdref->entry_group,
         sdref->service_interface,
         AVAHI_PROTO_UNSPEC,
         0,
         sdref->service_name_chosen,
-        sdref->service_regtype,
+        real_type ? real_type : sdref->service_regtype,
         sdref->service_domain,
         sdref->service_host,
         sdref->service_port,
         sdref->service_txt)) < 0)
         return ret;
 
+    
+    if (real_type) {
+        /* Create a subtype entry */
+
+        if (avahi_entry_group_add_service_subtype(
+                sdref->entry_group,
+                sdref->service_interface,
+                AVAHI_PROTO_UNSPEC,
+                0,
+                sdref->service_name_chosen,
+                real_type,
+                sdref->service_domain,
+                sdref->service_regtype) < 0)
+            return ret;
+
+    }
+
     if ((ret = avahi_entry_group_commit(sdref->entry_group)) < 0)
         return ret;
 
@@ -922,8 +967,10 @@ DNSServiceErrorType DNSSD_API DNSServiceRegister (
     assert(callback);
     assert(regtype);
 
-    if (interface == kDNSServiceInterfaceIndexLocalOnly || flags)
+    if (interface == kDNSServiceInterfaceIndexLocalOnly || flags) {
+        AVAHI_WARN_UNSUPPORTED;
         return kDNSServiceErr_Unsupported;
+    }
 
     if (!(sdref = sdref_new()))
         return kDNSServiceErr_Unknown;
@@ -932,9 +979,9 @@ DNSServiceErrorType DNSSD_API DNSServiceRegister (
     sdref->service_register_callback = callback;
 
     sdref->service_name = avahi_strdup(name);
-    sdref->service_regtype = avahi_strdup(regtype);
-    sdref->service_domain = avahi_strdup(domain);
-    sdref->service_host = avahi_strdup(host);
+    sdref->service_regtype = regtype ? avahi_normalize_name_strdup(regtype) : NULL;
+    sdref->service_domain = domain ? avahi_normalize_name_strdup(domain) : NULL;
+    sdref->service_host = host ? avahi_normalize_name_strdup(host) : NULL;
     sdref->service_interface = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
     sdref->service_port = ntohs(port);
     sdref->service_txt = txtRecord ? avahi_string_list_parse(txtRecord, txtLen) : NULL;