external/apache2/mDNSResponder/dist/mDNSShared/dnssd_clientlib.c

   1 /* -*- Mode: C; tab-width: 4 -*-
   2  *
   3  * Copyright (c) 2004, Apple Computer, Inc. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  * 1.  Redistributions of source code must retain the above copyright notice,
   9  *     this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright notice,
  11  *     this list of conditions and the following disclaimer in the documentation
  12  *     and/or other materials provided with the distribution.
  13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of its
  14  *     contributors may be used to endorse or promote products derived from this
  15  *     software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  26  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28    Change History (most recent first):
  29
  30 Log: dnssd_clientlib.c,v $
  31 Revision 1.21  2009/04/01 21:10:11  herscher
  32 <rdar://problem/5925472> Current Bonjour code does not compile on Windows. Use _stricmp and _strnicmp.
  33
  34 Revision 1.20  2008/11/26 20:57:37  cheshire
  35 For consistency with other similar macros, renamed mdnsIsDigit/mdnsIsLetter/mdnsValidHostChar
  36 to mDNSIsDigit/mDNSIsLetter/mDNSValidHostChar
  37
  38 Revision 1.19  2008/11/04 21:15:18  cheshire
  39 <rdar://problem/5969564> Potential buffer overflows in DNSServiceConstructFullName
  40
  41 Revision 1.18  2007/11/30 23:06:10  cheshire
  42 Fixed compile warning: declaration of 'index' shadows a global declaration
  43
  44 Revision 1.17  2007/10/02 19:36:04  cheshire
  45 <rdar://problem/5516444> TXTRecordGetValuePtr should be case-insenstive
  46
  47 Revision 1.16  2007/09/18 19:09:02  cheshire
  48 <rdar://problem/5489549> mDNSResponderHelper (and other binaries) missing SCCS version strings
  49
  50 Revision 1.15  2007/07/28 00:00:43  cheshire
  51 Renamed CompileTimeAssertionCheck structure for consistency with others
  52
  53 Revision 1.14  2007/03/20 17:07:16  cheshire
  54 Rename "struct uDNS_TCPSocket_struct" to "TCPSocket", "struct uDNS_UDPSocket_struct" to "UDPSocket"
  55
  56 Revision 1.13  2007/02/27 00:25:03  cheshire
  57 <rdar://problem/5010640> DNSServiceConstructFullName() doesn't handle empty string for instance name
  58
  59 Revision 1.12  2007/02/07 19:32:00  cheshire
  60 <rdar://problem/4980353> All mDNSResponder components should contain version strings in SCCS-compatible format
  61
  62 Revision 1.11  2006/08/14 23:05:53  cheshire
  63 Added "tab-width" emacs header line
  64
  65 Revision 1.10  2005/04/06 02:06:56  shersche
  66 Add DNSSD_API macro to TXTRecord API calls
  67
  68 Revision 1.9  2004/10/06 02:22:19  cheshire
  69 Changed MacRoman copyright symbol (should have been UTF-8 in any case :-) to ASCII-compatible "(c)"
  70
  71 Revision 1.8  2004/10/01 22:15:55  rpantos
  72 rdar://problem/3824265: Replace APSL in client lib with BSD license.
  73
  74 Revision 1.7  2004/06/26 03:16:34  shersche
  75 clean up warning messages on Win32 platform
  76
  77 Submitted by: herscher
  78
  79 Revision 1.6  2004/06/12 01:09:45  cheshire
  80 To be callable from the broadest range of clients on Windows (e.g. Visual Basic, C#, etc.)
  81 API routines have to be declared as "__stdcall", instead of the C default, "__cdecl"
  82
  83 Revision 1.5  2004/05/25 18:29:33  cheshire
  84 Move DNSServiceConstructFullName() from dnssd_clientstub.c to dnssd_clientlib.c,
  85 so that it's also accessible to dnssd_clientshim.c (single address space) clients.
  86
  87 Revision 1.4  2004/05/25 17:08:55  cheshire
  88 Fix compiler warning (doesn't make sense for function return type to be const)
  89
  90 Revision 1.3  2004/05/21 21:41:35  cheshire
  91 Add TXT record building and parsing APIs
  92
  93 Revision 1.2  2004/05/20 22:22:21  cheshire
  94 Enable code that was bracketed by "#if 0"
  95
  96 Revision 1.1  2004/03/12 21:30:29  cheshire
  97 Build a System-Context Shared Library from mDNSCore, for the benefit of developers
  98 like Muse Research who want to be able to use mDNS/DNS-SD from GPL-licensed code.
  99
 100  */
 101
 102 #include <stdlib.h>
 103 #include <string.h>
 104
 105 #include "dns_sd.h"
 106
 107 #if MDNS_BUILDINGSHAREDLIBRARY || MDNS_BUILDINGSTUBLIBRARY
 108 #pragma export on
 109 #endif
 110
 111 #if defined(_WIN32)
 112 // disable warning "conversion from <data> to uint16_t"
 113 #pragma warning(disable:4244)
 114 #define strncasecmp _strnicmp
 115 #define strcasecmp _stricmp
 116 #endif
 117
 118 /*********************************************************************************************
 119  *
 120  *  Supporting Functions
 121  *
 122  *********************************************************************************************/
 123
 124 #define mDNSIsDigit(X)     ((X) >= '0' && (X) <= '9')
 125
 126 // DomainEndsInDot returns 1 if name ends with a dot, 0 otherwise
 127 // (DNSServiceConstructFullName depends this returning 1 for true, rather than any non-zero value meaning true)
 128
 129 static int DomainEndsInDot(const char *dom)
 130         {
 131         while (dom[0] && dom[1])
 132                 {
 133                 if (dom[0] == '\\') // advance past escaped byte sequence
 134                         {
 135                         if (mDNSIsDigit(dom[1]) && mDNSIsDigit(dom[2]) && mDNSIsDigit(dom[3]))
 136                                 dom += 4;                       // If "\ddd"    then skip four
 137                         else dom += 2;                  // else if "\x" then skip two
 138                         }
 139                 else dom++;                                     // else goto next character
 140                 }
 141         return (dom[0] == '.');
 142         }
 143
 144 static uint8_t *InternalTXTRecordSearch
 145         (
 146         uint16_t         txtLen,
 147         const void       *txtRecord,
 148         const char       *key,
 149         unsigned long    *keylen
 150         )
 151         {
 152         uint8_t *p = (uint8_t*)txtRecord;
 153         uint8_t *e = p + txtLen;
 154         *keylen = (unsigned long) strlen(key);
 155         while (p<e)
 156                 {
 157                 uint8_t *x = p;
 158                 p += 1 + p[0];
 159                 if (p <= e && *keylen <= x[0] && !strncasecmp(key, (char*)x+1, *keylen))
 160                         if (*keylen == x[0] || x[1+*keylen] == '=') return(x);
 161                 }
 162         return(NULL);
 163         }
 164
 165 /*********************************************************************************************
 166  *
 167  *  General Utility Functions
 168  *
 169  *********************************************************************************************/
 170
 171 // Note: Need to make sure we don't write more than kDNSServiceMaxDomainName (1009) bytes to fullName
 172 // In earlier builds this constant was defined to be 1005, so to avoid buffer overruns on clients
 173 // compiled with that constant we'll actually limit the output to 1005 bytes.
 174
 175 DNSServiceErrorType DNSSD_API DNSServiceConstructFullName
 176         (
 177         char       *const fullName,
 178         const char *const service,      // May be NULL
 179         const char *const regtype,
 180         const char *const domain
 181         )
 182         {
 183         const size_t len = !regtype ? 0 : strlen(regtype) - DomainEndsInDot(regtype);
 184         char       *fn   = fullName;
 185         char *const lim  = fullName + 1005;
 186         const char *s    = service;
 187         const char *r    = regtype;
 188         const char *d    = domain;
 189
 190         // regtype must be at least "x._udp" or "x._tcp"
 191         if (len < 6 || !domain || !domain[0]) return kDNSServiceErr_BadParam;
 192         if (strncasecmp((regtype + len - 4), "_tcp", 4) && strncasecmp((regtype + len - 4), "_udp", 4)) return kDNSServiceErr_BadParam;
 193
 194         if (service && *service)
 195                 {
 196                 while (*s)
 197                         {
 198                         unsigned char c = *s++;                         // Needs to be unsigned, or values like 0xFF will be interpreted as < 32
 199                         if (c <= ' ')                                           // Escape non-printable characters
 200                                 {
 201                                 if (fn+4 >= lim) goto fail;
 202                                 *fn++ = '\\';
 203                                 *fn++ = '0' + (c / 100);
 204                                 *fn++ = '0' + (c /  10) % 10;
 205                                 c     = '0' + (c      ) % 10;
 206                                 }
 207                         else if (c == '.' || (c == '\\'))       // Escape dot and backslash literals
 208                                 {
 209                                 if (fn+2 >= lim) goto fail;
 210                                 *fn++ = '\\';
 211                                 }
 212                         else
 213                                 if (fn+1 >= lim) goto fail;
 214                         *fn++ = (char)c;
 215                         }
 216                 *fn++ = '.';
 217                 }
 218
 219         while (*r) if (fn+1 >= lim) goto fail; else *fn++ = *r++;
 220         if (!DomainEndsInDot(regtype)) { if (fn+1 >= lim) goto fail; else *fn++ = '.'; }
 221
 222         while (*d) if (fn+1 >= lim) goto fail; else *fn++ = *d++;
 223         if (!DomainEndsInDot(domain)) { if (fn+1 >= lim) goto fail; else *fn++ = '.'; }
 224
 225         *fn = '\0';
 226         return kDNSServiceErr_NoError;
 227
 228 fail:
 229         *fn = '\0';
 230         return kDNSServiceErr_BadParam;
 231         }
 232
 233 /*********************************************************************************************
 234  *
 235  *   TXT Record Construction Functions
 236  *
 237  *********************************************************************************************/
 238
 239 typedef struct _TXTRecordRefRealType
 240         {
 241         uint8_t  *buffer;               // Pointer to data
 242         uint16_t buflen;                // Length of buffer
 243         uint16_t datalen;               // Length currently in use
 244         uint16_t malloced;      // Non-zero if buffer was allocated via malloc()
 245         } TXTRecordRefRealType;
 246
 247 #define txtRec ((TXTRecordRefRealType*)txtRecord)
 248
 249 // The opaque storage defined in the public dns_sd.h header is 16 bytes;
 250 // make sure we don't exceed that.
 251 struct CompileTimeAssertionCheck_dnssd_clientlib
 252         {
 253         char assert0[(sizeof(TXTRecordRefRealType) <= 16) ? 1 : -1];
 254         };
 255
 256 void DNSSD_API TXTRecordCreate
 257         (
 258         TXTRecordRef     *txtRecord,
 259         uint16_t         bufferLen,
 260         void             *buffer
 261         )
 262         {
 263         txtRec->buffer   = buffer;
 264         txtRec->buflen   = buffer ? bufferLen : (uint16_t)0;
 265         txtRec->datalen  = 0;
 266         txtRec->malloced = 0;
 267         }
 268
 269 void DNSSD_API TXTRecordDeallocate(TXTRecordRef *txtRecord)
 270         {
 271         if (txtRec->malloced) free(txtRec->buffer);
 272         }
 273
 274 DNSServiceErrorType DNSSD_API TXTRecordSetValue
 275         (
 276         TXTRecordRef     *txtRecord,
 277         const char       *key,
 278         uint8_t          valueSize,
 279         const void       *value
 280         )
 281         {
 282         uint8_t *start, *p;
 283         const char *k;
 284         unsigned long keysize, keyvalsize;
 285
 286         for (k = key; *k; k++) if (*k < 0x20 || *k > 0x7E || *k == '=') return(kDNSServiceErr_Invalid);
 287         keysize = (unsigned long)(k - key);
 288         keyvalsize = 1 + keysize + (value ? (1 + valueSize) : 0);
 289         if (keysize < 1 || keyvalsize > 255) return(kDNSServiceErr_Invalid);
 290         (void)TXTRecordRemoveValue(txtRecord, key);
 291         if (txtRec->datalen + keyvalsize > txtRec->buflen)
 292                 {
 293                 unsigned char *newbuf;
 294                 unsigned long newlen = txtRec->datalen + keyvalsize;
 295                 if (newlen > 0xFFFF) return(kDNSServiceErr_Invalid);
 296                 newbuf = malloc((size_t)newlen);
 297                 if (!newbuf) return(kDNSServiceErr_NoMemory);
 298                 memcpy(newbuf, txtRec->buffer, txtRec->datalen);
 299                 if (txtRec->malloced) free(txtRec->buffer);
 300                 txtRec->buffer = newbuf;
 301                 txtRec->buflen = (uint16_t)(newlen);
 302                 txtRec->malloced = 1;
 303                 }
 304         start = txtRec->buffer + txtRec->datalen;
 305         p = start + 1;
 306         memcpy(p, key, keysize);
 307         p += keysize;
 308         if (value)
 309                 {
 310                 *p++ = '=';
 311                 memcpy(p, value, valueSize);
 312                 p += valueSize;
 313                 }
 314         *start = (uint8_t)(p - start - 1);
 315         txtRec->datalen += p - start;
 316         return(kDNSServiceErr_NoError);
 317         }
 318
 319 DNSServiceErrorType DNSSD_API TXTRecordRemoveValue
 320         (
 321         TXTRecordRef     *txtRecord,
 322         const char       *key
 323         )
 324         {
 325         unsigned long keylen, itemlen, remainder;
 326         uint8_t *item = InternalTXTRecordSearch(txtRec->datalen, txtRec->buffer, key, &keylen);
 327         if (!item) return(kDNSServiceErr_NoSuchKey);
 328         itemlen   = (unsigned long)(1 + item[0]);
 329         remainder = (unsigned long)((txtRec->buffer + txtRec->datalen) - (item + itemlen));
 330         // Use memmove because memcpy behaviour is undefined for overlapping regions
 331         memmove(item, item + itemlen, remainder);
 332         txtRec->datalen -= itemlen;
 333         return(kDNSServiceErr_NoError);
 334         }
 335
 336 uint16_t DNSSD_API TXTRecordGetLength  (const TXTRecordRef *txtRecord) { return(txtRec->datalen); }
 337 const void * DNSSD_API TXTRecordGetBytesPtr(const TXTRecordRef *txtRecord) { return(txtRec->buffer); }
 338
 339 /*********************************************************************************************
 340  *
 341  *   TXT Record Parsing Functions
 342  *
 343  *********************************************************************************************/
 344
 345 int DNSSD_API TXTRecordContainsKey
 346         (
 347         uint16_t         txtLen,
 348         const void       *txtRecord,
 349         const char       *key
 350         )
 351         {
 352         unsigned long keylen;
 353         return (InternalTXTRecordSearch(txtLen, txtRecord, key, &keylen) ? 1 : 0);
 354         }
 355
 356 const void * DNSSD_API TXTRecordGetValuePtr
 357         (
 358         uint16_t         txtLen,
 359         const void       *txtRecord,
 360         const char       *key,
 361         uint8_t          *valueLen
 362         )
 363         {
 364         unsigned long keylen;
 365         uint8_t *item = InternalTXTRecordSearch(txtLen, txtRecord, key, &keylen);
 366         if (!item || item[0] <= keylen) return(NULL);   // If key not found, or found with no value, return NULL
 367         *valueLen = (uint8_t)(item[0] - (keylen + 1));
 368         return (item + 1 + keylen + 1);
 369         }
 370
 371 uint16_t DNSSD_API TXTRecordGetCount
 372         (
 373         uint16_t         txtLen,
 374         const void       *txtRecord
 375         )
 376         {
 377         uint16_t count = 0;
 378         uint8_t *p = (uint8_t*)txtRecord;
 379         uint8_t *e = p + txtLen;
 380         while (p<e) { p += 1 + p[0]; count++; }
 381         return((p>e) ? (uint16_t)0 : count);
 382         }
 383
 384 DNSServiceErrorType DNSSD_API TXTRecordGetItemAtIndex
 385         (
 386         uint16_t         txtLen,
 387         const void       *txtRecord,
 388         uint16_t         itemIndex,
 389         uint16_t         keyBufLen,
 390         char             *key,
 391         uint8_t          *valueLen,
 392         const void       **value
 393         )
 394         {
 395         uint16_t count = 0;
 396         uint8_t *p = (uint8_t*)txtRecord;
 397         uint8_t *e = p + txtLen;
 398         while (p<e && count<itemIndex) { p += 1 + p[0]; count++; }      // Find requested item
 399         if (p<e && p + 1 + p[0] <= e)   // If valid
 400                 {
 401                 uint8_t *x = p+1;
 402                 unsigned long len = 0;
 403                 e = p + 1 + p[0];
 404                 while (x+len<e && x[len] != '=') len++;
 405                 if (len >= keyBufLen) return(kDNSServiceErr_NoMemory);
 406                 memcpy(key, x, len);
 407                 key[len] = 0;
 408                 if (x+len<e)            // If we found '='
 409                         {
 410                         *value = x + len + 1;
 411                         *valueLen = (uint8_t)(p[0] - (len + 1));
 412                         }
 413                 else
 414                         {
 415                         *value = NULL;
 416                         *valueLen = 0;
 417                         }
 418                 return(kDNSServiceErr_NoError);
 419                 }
 420         return(kDNSServiceErr_Invalid);
 421         }
 422
 423 /*********************************************************************************************
 424  *
 425  *   SCCS-compatible version string
 426  *
 427  *********************************************************************************************/
 428
 429 // For convenience when using the "strings" command, this is the last thing in the file
 430
 431 // Note: The C preprocessor stringify operator ('#') makes a string from its argument, without macro expansion
 432 // e.g. If "version" is #define'd to be "4", then STRINGIFY_AWE(version) will return the string "version", not "4"
 433 // To expand "version" to its value before making the string, use STRINGIFY(version) instead
 434 #define STRINGIFY_ARGUMENT_WITHOUT_EXPANSION(s) #s
 435 #define STRINGIFY(s) STRINGIFY_ARGUMENT_WITHOUT_EXPANSION(s)
 436
 437 // NOT static -- otherwise the compiler may optimize it out
 438 // The "@(#) " pattern is a special prefix the "what" command looks for
 439 const char VersionString_SCCS_libdnssd[] = "@(#) libdns_sd " STRINGIFY(mDNSResponderVersion) " (" __DATE__ " " __TIME__ ")";