X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=avahi-compat-libdns_sd%2Fcompat.c;h=7c2686a72c9a682727b6da5bc63a9b0c72ae5b87;hb=d173d6630d3bf1ff17c874cdc105ff6016df5377;hp=6433f6d6a04f39674a460522563bbda534ab88a7;hpb=e521a9a2fad8314d5e7d5bbde47b2c852a1426a7;p=catta

diff --git a/avahi-compat-libdns_sd/compat.c b/avahi-compat-libdns_sd/compat.c
index 6433f6d..7c2686a 100644
--- a/avahi-compat-libdns_sd/compat.c
+++ b/avahi-compat-libdns_sd/compat.c
@@ -469,25 +469,26 @@ static void sdref_unref(DNSServiceRef sdref) {
 }
 
 int DNSSD_API DNSServiceRefSockFD(DNSServiceRef sdref) {
-    if (!sdref || sdref->n_ref <= 0)
-        return -1;
 
     AVAHI_WARN_LINKAGE;
     
+    if (!sdref || sdref->n_ref <= 0)
+        return -1;
+
     return sdref->main_fd;
 }
 
 DNSServiceErrorType DNSSD_API DNSServiceProcessResult(DNSServiceRef sdref) {
     DNSServiceErrorType ret = kDNSServiceErr_Unknown;
 
-    assert(sdref);
-    assert(sdref->n_ref >= 1);
-    
     AVAHI_WARN_LINKAGE;
 
-    ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
-
+    if (!sdref || sdref->n_ref <= 0)
+        return kDNSServiceErr_BadParam;
+    
     sdref_ref(sdref);
+
+    ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
     
     /* Cleanup notification socket */
     if (read_command(sdref->main_fd) != COMMAND_POLL_DONE)
@@ -512,10 +513,10 @@ DNSServiceErrorType DNSSD_API DNSServiceProcessResult(DNSServiceRef sdref) {
     
 finish:
 
-    sdref_unref(sdref);
-
     ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
     
+    sdref_unref(sdref);
+
     return ret;
 }
 
@@ -610,10 +611,10 @@ DNSServiceErrorType DNSSD_API DNSServiceBrowse(
     struct type_info type_info;
     
     AVAHI_WARN_LINKAGE;
-    
-    assert(ret_sdref);
-    assert(regtype);
-    assert(callback);
+
+    if (!ret_sdref || !regtype)
+        return kDNSServiceErr_BadParam;
+    *ret_sdref = NULL;
 
     if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
         AVAHI_WARN_UNSUPPORTED;
@@ -707,7 +708,7 @@ static void service_resolver_callback(
 
             strcat(full_name, ".");
             
-            sdref->service_resolver_callback(sdref, 0, interface, kDNSServiceErr_NoError, full_name, host_name, htons(port), l, p, sdref->context);
+            sdref->service_resolver_callback(sdref, 0, interface, kDNSServiceErr_NoError, full_name, host_name, htons(port), l, (unsigned char*) p, sdref->context);
 
             avahi_free(p);
             break;
@@ -736,11 +737,9 @@ DNSServiceErrorType DNSSD_API DNSServiceResolve(
 
     AVAHI_WARN_LINKAGE;
 
-    assert(ret_sdref);
-    assert(name);
-    assert(regtype);
-    assert(domain);
-    assert(callback);
+    if (!ret_sdref || !name || !regtype || !domain || !callback)
+        return kDNSServiceErr_BadParam;
+    *ret_sdref = NULL;
 
     if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
         AVAHI_WARN_UNSUPPORTED;
@@ -789,9 +788,8 @@ int DNSSD_API DNSServiceConstructFullName (
 
     AVAHI_WARN_LINKAGE;
 
-    assert(fullName);
-    assert(regtype);
-    assert(domain);
+    if (!fullName || !regtype || !domain)
+        return -1;
 
     if (avahi_service_name_join(fullName, kDNSServiceMaxDomainName, service, regtype, domain) < 0)
         return -1;
@@ -850,8 +848,9 @@ DNSServiceErrorType DNSSD_API DNSServiceEnumerateDomains(
 
     AVAHI_WARN_LINKAGE;
 
-    assert(ret_sdref);
-    assert(callback);
+    if (!ret_sdref || !callback)
+        return kDNSServiceErr_BadParam;
+    *ret_sdref = NULL;
 
     if (interface == kDNSServiceInterfaceIndexLocalOnly ||
         (flags != kDNSServiceFlagsBrowseDomains &&  flags != kDNSServiceFlagsRegistrationDomains)) {
@@ -991,6 +990,16 @@ static void reg_client_callback(AvahiClient *s, AvahiClientState state, void* us
                     return;
                 }
             }
+
+            if (!sdref->service_name_chosen) {
+
+                assert(sdref->service_name);
+                
+                if (!(sdref->service_name_chosen = avahi_strdup(sdref->service_name))) {
+                    reg_report_error(sdref, kDNSServiceErr_NoMemory);
+                    return;
+                }
+            }
             
             /* Register the service */
 
@@ -1024,6 +1033,7 @@ static void reg_entry_group_callback(AvahiEntryGroup *g, AvahiEntryGroupState st
 
     switch (state) {
         case AVAHI_ENTRY_GROUP_ESTABLISHED:
+
             /* Inform the user */
             reg_report_error(sdref, kDNSServiceErr_NoError);
 
@@ -1090,15 +1100,21 @@ DNSServiceErrorType DNSSD_API DNSServiceRegister (
 
     AVAHI_WARN_LINKAGE;
 
-    assert(ret_sdref);
-    assert(regtype);
+    if (!ret_sdref || !regtype)
+        return kDNSServiceErr_BadParam;
+    *ret_sdref = NULL;
+    
+    if (!txtRecord) {
+        txtLen = 1;
+        txtRecord = "";
+    }
 
     if (interface == kDNSServiceInterfaceIndexLocalOnly || flags) {
         AVAHI_WARN_UNSUPPORTED;
         return kDNSServiceErr_Unsupported;
     }
 
-    if (txtRecord && txtLen > 0) 
+    if (txtLen > 0) 
         if (avahi_string_list_parse(txtRecord, txtLen, &txt) < 0)
             return kDNSServiceErr_Invalid;
 
@@ -1189,3 +1205,65 @@ finish:
     return ret;
 }
 
+DNSServiceErrorType DNSSD_API DNSServiceUpdateRecord(
+         DNSServiceRef sdref,
+         DNSRecordRef rref,     
+         DNSServiceFlags flags,
+         uint16_t rdlen,
+         const void *rdata,
+         AVAHI_GCC_UNUSED uint32_t ttl) {
+
+    int ret = kDNSServiceErr_Unknown;
+    AvahiStringList *txt = NULL;
+
+    AVAHI_WARN_LINKAGE;
+
+    if (!sdref || sdref->n_ref <= 0)
+        return kDNSServiceErr_BadParam;
+
+    if (flags || rref) {
+        AVAHI_WARN_UNSUPPORTED;
+        return kDNSServiceErr_Unsupported;
+    }
+
+    if (rdlen > 0) 
+        if (avahi_string_list_parse(rdata, rdlen, &txt) < 0)
+            return kDNSServiceErr_Invalid;
+
+    ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
+
+    if (!avahi_string_list_equal(txt, sdref->service_txt)) {
+
+        avahi_string_list_free(sdref->service_txt);
+        sdref->service_txt = txt;
+
+        if (avahi_client_get_state(sdref->client) == AVAHI_CLIENT_S_RUNNING &&
+            sdref->entry_group &&
+            (avahi_entry_group_get_state(sdref->entry_group) == AVAHI_ENTRY_GROUP_ESTABLISHED ||
+            avahi_entry_group_get_state(sdref->entry_group) == AVAHI_ENTRY_GROUP_REGISTERING))
+
+            if (avahi_entry_group_update_service_txt_strlst(
+                        sdref->entry_group,
+                        sdref->service_interface,
+                        AVAHI_PROTO_UNSPEC,
+                        0,
+                        sdref->service_name_chosen,
+                        sdref->type_info.type,
+                        sdref->service_domain,
+                        sdref->service_txt) < 0) {
+                
+                ret = map_error(avahi_client_errno(sdref->client));
+                goto finish;
+            }
+
+    } else
+        avahi_string_list_free(txt);
+
+    ret = kDNSServiceErr_NoError;
+    
+finish:
+    ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
+    
+    return ret;
+}
+