first version of the zeroconf lib

allows browsing (detection) of services using dns-sd, i.e.
DNS Service Discovery, or Bonjour see http://www.zeroconf.org/
The exposed interface is reentrant and threadsafe

Change-Id: I957d69696aa3c8ad625e074389b649b00b9153cf
Reviewed-on: http://codereview.qt-project.org/5410


Reviewed-by: Fawzi Mohamed <fawzi.mohamed@nokia.com>
Sanity-Review: Qt Sanity Bot <qt_sanity_bot@ovi.com>

src/libs/libs.pro

@@ -16,7 +16,8 @@ SUBDIRS   = \
     qmljsdebugclient \
     glsl \
     qmleditorwidgets \
-    qtcomponents/styleitem
+    qtcomponents/styleitem \
+    zeroconf
 win32:SUBDIRS += utils/process_ctrlc_stub.pro
 
 # Windows: Compile Qt Creator CDB extension if Debugging tools can be detected.    

src/libs/zeroconf/embed/dnssd_clientlib.c

+/* -*- Mode: C; tab-width: 4 -*-
+ *
+ * Copyright (c) 2004, Apple Computer, Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of its
+ *     contributors may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "dns_sd_types.h"
+
+#if MDNS_BUILDINGSHAREDLIBRARY || MDNS_BUILDINGSTUBLIBRARY
+//#pragma export on
+#endif
+
+#if defined(_WIN32)
+// disable warning "conversion from <data> to uint16_t"
+#pragma warning(disable:4244)
+#define strncasecmp _strnicmp
+#define strcasecmp _stricmp
+#endif
+
+/*********************************************************************************************
+ *
+ *  Supporting Functions
+ *
+ *********************************************************************************************/
+namespace ZeroConf { namespace embeddedLib {
+
+#include "dns_sd_funct.h"
+
+#define mDNSIsDigit(X)     ((X) >= '0' && (X) <= '9')
+
+// DomainEndsInDot returns 1 if name ends with a dot, 0 otherwise
+// (DNSServiceConstructFullName depends this returning 1 for true, rather than any non-zero value meaning true)
+
+static int DomainEndsInDot(const char *dom)
+        {
+        while (dom[0] && dom[1])
+                {
+                if (dom[0] == '\\') // advance past escaped byte sequence
+                        {
+                        if (mDNSIsDigit(dom[1]) && mDNSIsDigit(dom[2]) && mDNSIsDigit(dom[3]))
+                                dom += 4;            // If "\ddd"    then skip four
+                        else dom += 2;            // else if "\x" then skip two
+                        }
+                else dom++;                    // else goto next character
+                }
+        return (dom[0] == '.');
+        }
+
+static uint8_t *InternalTXTRecordSearch
+        (
+        uint16_t         txtLen,
+        const void       *txtRecord,
+        const char       *key,
+        unsigned long    *keylen
+        )
+        {
+        uint8_t *p = (uint8_t*)txtRecord;
+        uint8_t *e = p + txtLen;
+        *keylen = (unsigned long) strlen(key);
+        while (p<e)
+                {
+                uint8_t *x = p;
+                p += 1 + p[0];
+                if (p <= e && *keylen <= x[0] && !strncasecmp(key, (char*)x+1, *keylen))
+                        if (*keylen == x[0] || x[1+*keylen] == '=') return(x);
+                }
+        return(NULL);
+        }
+
+/*********************************************************************************************
+ *
+ *  General Utility Functions
+ *
+ *********************************************************************************************/
+
+// Note: Need to make sure we don't write more than kDNSServiceMaxDomainName (1009) bytes to fullName
+// In earlier builds this constant was defined to be 1005, so to avoid buffer overruns on clients
+// compiled with that constant we'll actually limit the output to 1005 bytes.
+
+DNSServiceErrorType DNSSD_API DNSServiceConstructFullName
+        (
+        char       *const fullName,
+        const char *const service,      // May be NULL
+        const char *const regtype,
+        const char *const domain
+        )
+        {
+        const size_t len = !regtype ? 0 : strlen(regtype) - DomainEndsInDot(regtype);
+        char       *fn   = fullName;
+        char *const lim  = fullName + 1005;
+        const char *s    = service;
+        const char *r    = regtype;
+        const char *d    = domain;
+
+        // regtype must be at least "x._udp" or "x._tcp"
+        if (len < 6 || !domain || !domain[0]) return kDNSServiceErr_BadParam;
+        if (strncasecmp((regtype + len - 4), "_tcp", 4) && strncasecmp((regtype + len - 4), "_udp", 4)) return kDNSServiceErr_BadParam;
+
+        if (service && *service)
+                {
+                while (*s)
+                        {
+                        unsigned char c = *s++;                // Needs to be unsigned, or values like 0xFF will be interpreted as < 32
+                        if (c <= ' ')                        // Escape non-printable characters
+                                {
+                                if (fn+4 >= lim) goto fail;
+                                *fn++ = '\\';
+                                *fn++ = '0' + (c / 100);
+                                *fn++ = '0' + (c /  10) % 10;
+                                c     = '0' + (c      ) % 10;
+                                }
+                        else if (c == '.' || (c == '\\'))    // Escape dot and backslash literals
+                                {
+                                if (fn+2 >= lim) goto fail;
+                                *fn++ = '\\';
+                                }
+                        else
+                                if (fn+1 >= lim) goto fail;
+                        *fn++ = (char)c;
+                        }
+                *fn++ = '.';
+                }
+
+        while (*r) if (fn+1 >= lim) goto fail; else *fn++ = *r++;
+        if (!DomainEndsInDot(regtype)) { if (fn+1 >= lim) goto fail; else *fn++ = '.'; }
+
+        while (*d) if (fn+1 >= lim) goto fail; else *fn++ = *d++;
+        if (!DomainEndsInDot(domain)) { if (fn+1 >= lim) goto fail; else *fn++ = '.'; }
+
+        *fn = '\0';
+        return kDNSServiceErr_NoError;
+
+fail:
+        *fn = '\0';
+        return kDNSServiceErr_BadParam;
+        }
+
+/*********************************************************************************************
+ *
+ *   TXT Record Construction Functions
+ *
+ *********************************************************************************************/
+
+typedef struct _TXTRecordRefRealType
+        {
+        uint8_t *buffer;        // Pointer to data
+        uint16_t buflen;        // Length of buffer
+        uint16_t datalen;        // Length currently in use
+        uint16_t malloced;    // Non-zero if buffer was allocated via malloc()
+        } TXTRecordRefRealType;
+
+#define txtRec ((TXTRecordRefRealType*)txtRecord)
+
+// The opaque storage defined in the public dns_sd.h header is 16 bytes;
+// make sure we don't exceed that.
+struct CompileTimeAssertionCheck_dnssd_clientlib
+        {
+        char assert0[(sizeof(TXTRecordRefRealType) <= 16) ? 1 : -1];
+        };
+
+void DNSSD_API TXTRecordCreate
+        (
+        TXTRecordRef     *txtRecord,
+        uint16_t         bufferLen,
+        void             *buffer
+        )
+        {
+        txtRec->buffer   = static_cast<uint8_t  *>(buffer);
+        txtRec->buflen   = buffer ? bufferLen : (uint16_t)0;
+        txtRec->datalen  = 0;
+        txtRec->malloced = 0;
+        }
+
+void DNSSD_API TXTRecordDeallocate(TXTRecordRef *txtRecord)
+        {
+        if (txtRec->malloced) free(txtRec->buffer);
+        }
+
+DNSServiceErrorType DNSSD_API TXTRecordSetValue
+        (
+        TXTRecordRef     *txtRecord,
+        const char       *key,
+        uint8_t          valueSize,
+        const void       *value
+        )
+        {
+        uint8_t *start, *p;
+        const char *k;
+        unsigned long keysize, keyvalsize;
+
+        for (k = key; *k; k++) if (*k < 0x20 || *k > 0x7E || *k == '=') return(kDNSServiceErr_Invalid);
+        keysize = (unsigned long)(k - key);
+        keyvalsize = 1 + keysize + (value ? (1 + valueSize) : 0);
+        if (keysize < 1 || keyvalsize > 255) return(kDNSServiceErr_Invalid);
+        (void)TXTRecordRemoveValue(txtRecord, key);
+        if (txtRec->datalen + keyvalsize > txtRec->buflen)
+                {
+                unsigned char *newbuf;
+                unsigned long newlen = txtRec->datalen + keyvalsize;
+                if (newlen > 0xFFFF) return(kDNSServiceErr_Invalid);
+                newbuf = static_cast<unsigned char *>(malloc((size_t)newlen));
+                if (!newbuf) return(kDNSServiceErr_NoMemory);
+                memcpy(newbuf, txtRec->buffer, txtRec->datalen);
+                if (txtRec->malloced) free(txtRec->buffer);
+                txtRec->buffer = newbuf;
+                txtRec->buflen = (uint16_t)(newlen);
+                txtRec->malloced = 1;
+                }
+        start = txtRec->buffer + txtRec->datalen;
+        p = start + 1;
+        memcpy(p, key, keysize);
+        p += keysize;
+        if (value)
+                {
+                *p++ = '=';
+                memcpy(p, value, valueSize);
+                p += valueSize;
+                }
+        *start = (uint8_t)(p - start - 1);
+        txtRec->datalen += p - start;
+        return(kDNSServiceErr_NoError);
+        }
+
+DNSServiceErrorType DNSSD_API TXTRecordRemoveValue
+        (
+        TXTRecordRef     *txtRecord,
+        const char       *key
+        )
+        {
+        unsigned long keylen, itemlen, remainder;
+        uint8_t *item = InternalTXTRecordSearch(txtRec->datalen, txtRec->buffer, key, &keylen);
+        if (!item) return(kDNSServiceErr_NoSuchKey);
+        itemlen   = (unsigned long)(1 + item[0]);
+        remainder = (unsigned long)((txtRec->buffer + txtRec->datalen) - (item + itemlen));
+        // Use memmove because memcpy behaviour is undefined for overlapping regions
+        memmove(item, item + itemlen, remainder);
+        txtRec->datalen -= itemlen;
+        return(kDNSServiceErr_NoError);
+        }
+
+uint16_t DNSSD_API TXTRecordGetLength  (const TXTRecordRef *txtRecord) { return(txtRec->datalen); }
+const void * DNSSD_API TXTRecordGetBytesPtr(const TXTRecordRef *txtRecord) { return(txtRec->buffer); }
+
+/*********************************************************************************************
+ *
+ *   TXT Record Parsing Functions
+ *
+ *********************************************************************************************/
+
+int DNSSD_API TXTRecordContainsKey
+        (
+        uint16_t         txtLen,
+        const void       *txtRecord,
+        const char       *key
+        )
+        {
+        unsigned long keylen;
+        return (InternalTXTRecordSearch(txtLen, txtRecord, key, &keylen) ? 1 : 0);
+        }
+
+const void * DNSSD_API TXTRecordGetValuePtr
+        (
+        uint16_t         txtLen,
+        const void       *txtRecord,
+        const char       *key,
+        uint8_t          *valueLen
+        )
+        {
+        unsigned long keylen;
+        uint8_t *item = InternalTXTRecordSearch(txtLen, txtRecord, key, &keylen);
+        if (!item || item[0] <= keylen) return(NULL);    // If key not found, or found with no value, return NULL
+        *valueLen = (uint8_t)(item[0] - (keylen + 1));
+        return (item + 1 + keylen + 1);
+        }
+
+uint16_t DNSSD_API TXTRecordGetCount
+        (
+        uint16_t         txtLen,
+        const void       *txtRecord
+        )
+        {
+        uint16_t count = 0;
+        uint8_t *p = (uint8_t*)txtRecord;
+        uint8_t *e = p + txtLen;
+        while (p<e) { p += 1 + p[0]; count++; }
+        return((p>e) ? (uint16_t)0 : count);
+        }
+
+DNSServiceErrorType DNSSD_API TXTRecordGetItemAtIndex
+        (
+        uint16_t         txtLen,
+        const void       *txtRecord,
+        uint16_t         itemIndex,
+        uint16_t         keyBufLen,
+        char             *key,
+        uint8_t          *valueLen,
+        const void       **value
+        )
+        {
+        uint16_t count = 0;
+        uint8_t *p = (uint8_t*)txtRecord;
+        uint8_t *e = p + txtLen;
+        while (p<e && count<itemIndex) { p += 1 + p[0]; count++; }    // Find requested item
+        if (p<e && p + 1 + p[0] <= e)    // If valid
+                {
+                uint8_t *x = p+1;
+                unsigned long len = 0;
+                e = p + 1 + p[0];
+                while (x+len<e && x[len] != '=') len++;
+                if (len >= keyBufLen) return(kDNSServiceErr_NoMemory);
+                memcpy(key, x, len);
+                key[len] = 0;
+                if (x+len<e)        // If we found '='
+                        {
+                        *value = x + len + 1;
+                        *valueLen = (uint8_t)(p[0] - (len + 1));
+                        }
+                else
+                        {
+                        *value = NULL;
+                        *valueLen = 0;
+                        }
+                return(kDNSServiceErr_NoError);
+                }
+        return(kDNSServiceErr_Invalid);
+        }
+
+/*********************************************************************************************
+ *
+ *   SCCS-compatible version string
+ *
+ *********************************************************************************************/
+
+// For convenience when using the "strings" command, this is the last thing in the file
+
+// Note: The C preprocessor stringify operator ('#') makes a string from its argument, without macro expansion
+// e.g. If "version" is #define'd to be "4", then STRINGIFY_AWE(version) will return the string "version", not "4"
+// To expand "version" to its value before making the string, use STRINGIFY(version) instead
+#define STRINGIFY_ARGUMENT_WITHOUT_EXPANSION(s) #s
+#define STRINGIFY(s) STRINGIFY_ARGUMENT_WITHOUT_EXPANSION(s)
+
+// NOT static -- otherwise the compiler may optimize it out
+// The "@(#) " pattern is a special prefix the "what" command looks for
+const char VersionString_SCCS_libdnssd[] = "@(#) libdns_sd " STRINGIFY(mDNSResponderVersion) " (" __DATE__ " " __TIME__ ")";
+        }}

src/libs/zeroconf/mdnsderived.cpp

+/*
+ * Copyright (c) 2004, Apple Computer, Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of its
+ *     contributors may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "mdnsderived.h"
+#include "cstddef"
+#include "cstring"
+#ifdef _WIN32
+#define strncasecmp _strnicmp
+#endif
+
+namespace ZeroConf {
+namespace Internal {
+
+// DomainEndsInDot returns 1 if name ends with a dot, 0 otherwise
+// (DNSServiceConstructFullName depends this returning 1 for true, rather than any non-zero value meaning true)
+static int DomainEndsInDot(const char *dom)
+{
+    while (dom[0] && dom[1]) {
+        if (dom[0] == '\\') { // advance past escaped byte sequence
+            if ('0' <= dom[1] && dom[1] <= '9' &&
+                '0' <= dom[2] && dom[2] <= '9' &&
+                '0' <= dom[3] && dom[3] <= '9')
+            {
+                dom += 4;            // If "\ddd"    then skip four
+            } else {
+                dom += 2;            // else if "\x" then skip two
+            }
+        } else {
+            dom++;                    // else goto next character
+        }
+    }
+    return (dom[0] == '.');
+}
+
+// Note: Need to make sure we don't write more than kDNSServiceMaxDomainName (1009) bytes to fullName
+// In earlier builds this constant was defined to be 1005, so to avoid buffer overruns on clients
+// compiled with that constant we'll actually limit the output to 1005 bytes.
+DNSServiceErrorType myDNSServiceConstructFullName(char       *const fullName,
+                                                  const char *const service,      // May be NULL
+                                                  const char *const regtype,
+                                                  const char *const domain)
+{
+    const size_t len = !regtype ? 0 : strlen(regtype) - DomainEndsInDot(regtype);
+    char       *fn   = fullName;
+    char *const lim  = fullName + 1005;
+    const char *s    = service;
+    const char *r    = regtype;
+    const char *d    = domain;
+
+    // regtype must be at least "x._udp" or "x._tcp"
+    if (len < 6 || !domain || !domain[0]) return kDNSServiceErr_BadParam;
+    if (strncasecmp((regtype + len - 4), "_tcp", 4) && strncasecmp((regtype + len - 4), "_udp", 4)) return kDNSServiceErr_BadParam;
+
+    if (service && *service)
+    {
+        while (*s)
+        {
+            unsigned char c = *s++;                // Needs to be unsigned, or values like 0xFF will be interpreted as < 32
+            if (c <= ' ')                        // Escape non-printable characters
+            {
+                if (fn + 4 >= lim) goto fail;
+                *fn++ = '\\';
+                *fn++ = '0' + (c / 100);
+                *fn++ = '0' + (c /  10) % 10;
+                c     = '0' + (c      ) % 10;
+            }
+            else if (c == '.' || (c == '\\'))    // Escape dot and backslash literals
+            {
+                if (fn + 2 >= lim) goto fail;
+                *fn++ = '\\';
+            }
+            else
+                if (fn + 1 >= lim) goto fail;
+            *fn++ = (char)c;
+        }
+        *fn++ = '.';
+    }
+
+    while (*r) if (fn + 1 >= lim) goto fail; else *fn++ = *r++;
+    if (!DomainEndsInDot(regtype)) { if (fn + 1 >= lim) goto fail; else *fn++ = '.'; }
+
+    while (*d) if (fn + 1 >= lim) goto fail; else *fn++ = *d++;
+    if (!DomainEndsInDot(domain)) { if (fn + 1 >= lim) goto fail; else *fn++ = '.'; }
+
+    *fn = '\0';
+    return kDNSServiceErr_NoError;
+
+fail:
+    *fn = '\0';
+    return kDNSServiceErr_BadParam;
+}
+
+} // namespace ZeroConf
+} // namespace Internal

src/libs/zeroconf/zeroconf.pri

+INCLUDEPATH += $$PWD
+
+LIBS *= -l$$qtLibraryName(zeroconf)

src/libs/zeroconf/zeroconf.pro

+QT       -= gui
+QT       += network
+
+TARGET = zeroconf
+TEMPLATE = lib
+
+DEFINES += ZEROCONF_LIBRARY
+
+SOURCES += servicebrowser.cpp \
+    embeddedLib.cpp \
+    nativeLib.cpp \
+    mdnsderived.cpp
+
+HEADERS += servicebrowser.h\
+        zeroconf_global.h \
+        dns_sd_types.h \
+    servicebrowser_p.h \
+    mdnsderived.h
+
+include(../../qtcreatorlibrary.pri)
+
+win32{
+    LIBS += -lws2_32
+}
+