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.11  2006/08/14 23:05:53  cheshire
  32 Added "tab-width" emacs header line
  33
  34 Revision 1.10  2005/04/06 02:06:56  shersche
  35 Add DNSSD_API macro to TXTRecord API calls
  36
  37 Revision 1.9  2004/10/06 02:22:19  cheshire
  38 Changed MacRoman copyright symbol (should have been UTF-8 in any case :-) to ASCII-compatible "(c)"
  39
  40 Revision 1.8  2004/10/01 22:15:55  rpantos
  41 rdar://problem/3824265: Replace APSL in client lib with BSD license.
  42
  43 Revision 1.7  2004/06/26 03:16:34  shersche
  44 clean up warning messages on Win32 platform
  45
  46 Submitted by: herscher
  47
  48 Revision 1.6  2004/06/12 01:09:45  cheshire
  49 To be callable from the broadest range of clients on Windows (e.g. Visual Basic, C#, etc.)
  50 API routines have to be declared as "__stdcall", instead of the C default, "__cdecl"
  51
  52 Revision 1.5  2004/05/25 18:29:33  cheshire
  53 Move DNSServiceConstructFullName() from dnssd_clientstub.c to dnssd_clientlib.c,
  54 so that it's also accessible to dnssd_clientshim.c (single address space) clients.
  55
  56 Revision 1.4  2004/05/25 17:08:55  cheshire
  57 Fix compiler warning (doesn't make sense for function return type to be const)
  58
  59 Revision 1.3  2004/05/21 21:41:35  cheshire
  60 Add TXT record building and parsing APIs
  61
  62 Revision 1.2  2004/05/20 22:22:21  cheshire
  63 Enable code that was bracketed by "#if 0"
  64
  65 Revision 1.1  2004/03/12 21:30:29  cheshire
  66 Build a System-Context Shared Library from mDNSCore, for the benefit of developers
  67 like Muse Research who want to be able to use mDNS/DNS-SD from GPL-licensed code.
  68
  69  */
  70
  71 #include <stdlib.h>
  72 #include <string.h>
  73
  74 #include "dns_sd.h"
  75
  76 #if MDNS_BUILDINGSHAREDLIBRARY || MDNS_BUILDINGSTUBLIBRARY
  77 #pragma export on
  78 #endif
  79
  80 #if defined(_WIN32)
  81 // disable warning "conversion from <data> to uint16_t"
  82 #pragma warning(disable:4244)
  83 #endif
  84
  85 /*********************************************************************************************
  86  *
  87  *  Supporting Functions
  88  *
  89  *********************************************************************************************/
  90
  91 #define mdnsIsDigit(X)     ((X) >= '0' && (X) <= '9')
  92
  93 static int DomainEndsInDot(const char *dom)
  94         {
  95         while (dom[0] && dom[1])
  96                 {
  97                 if (dom[0] == '\\') // advance past escaped byte sequence
  98                         {
  99                         if (mdnsIsDigit(dom[1]) && mdnsIsDigit(dom[2]) && mdnsIsDigit(dom[3]))
 100                                 dom += 4;                       // If "\ddd"    then skip four
 101                         else dom += 2;                  // else if "\x" then skip two
 102                         }
 103                 else dom++;                                     // else goto next character
 104                 }
 105         return (dom[0] == '.');
 106         }
 107
 108 static uint8_t *InternalTXTRecordSearch
 109         (
 110         uint16_t         txtLen,
 111         const void       *txtRecord,
 112         const char       *key,
 113         unsigned long    *keylen
 114         )
 115         {
 116         uint8_t *p = (uint8_t*)txtRecord;
 117         uint8_t *e = p + txtLen;
 118         *keylen = (unsigned long) strlen(key);
 119         while (p<e)
 120                 {
 121                 uint8_t *x = p;
 122                 p += 1 + p[0];
 123                 if (p <= e && *keylen <= x[0] && !strncmp(key, (char*)x+1, *keylen))
 124                         if (*keylen == x[0] || x[1+*keylen] == '=') return(x);
 125                 }
 126         return(NULL);
 127         }
 128
 129 /*********************************************************************************************
 130  *
 131  *  General Utility Functions
 132  *
 133  *********************************************************************************************/
 134
 135 int DNSSD_API DNSServiceConstructFullName
 136         (
 137         char                      *fullName,
 138         const char                *service,      /* may be NULL */
 139         const char                *regtype,
 140         const char                *domain
 141         )
 142         {
 143         unsigned long len;
 144         unsigned char c;
 145         char *fn = fullName;
 146         const char *s = service;
 147         const char *r = regtype;
 148         const char *d = domain;
 149
 150         if (service)
 151                 {
 152                 while(*s)
 153                         {
 154                         c = (unsigned char)*s++;
 155                         if (c == '.' || (c == '\\')) *fn++ = '\\'; // escape dot and backslash literals
 156                         else if (c <= ' ') // escape non-printable characters
 157                                 {
 158                                 *fn++ = '\\';
 159                                 *fn++ = (char) ('0' + (c / 100));
 160                                 *fn++ = (char) ('0' + (c / 10) % 10);
 161                                 c = (unsigned char)('0' + (c % 10));
 162                                 }
 163                         *fn++ = (char)c;
 164                         }
 165                 *fn++ = '.';
 166                 }
 167
 168         if (!regtype) return -1;
 169         len = (unsigned long) strlen(regtype);
 170         if (DomainEndsInDot(regtype)) len--;
 171         if (len < 6) return -1; // regtype must be at least "x._udp" or "x._tcp"
 172         if (strncmp((regtype + len - 4), "_tcp", 4) && strncmp((regtype + len - 4), "_udp", 4)) return -1;
 173         while(*r) *fn++ = *r++;
 174         if (!DomainEndsInDot(regtype)) *fn++ = '.';
 175
 176         if (!domain || !domain[0]) return -1;
 177         while(*d) *fn++ = *d++;
 178         if (!DomainEndsInDot(domain)) *fn++ = '.';
 179         *fn = '\0';
 180         return 0;
 181         }
 182
 183 /*********************************************************************************************
 184  *
 185  *   TXT Record Construction Functions
 186  *
 187  *********************************************************************************************/
 188
 189 typedef struct _TXTRecordRefRealType
 190         {
 191         uint8_t  *buffer;               // Pointer to data
 192         uint16_t buflen;                // Length of buffer
 193         uint16_t datalen;               // Length currently in use
 194         uint16_t malloced;      // Non-zero if buffer was allocated via malloc()
 195         } TXTRecordRefRealType;
 196
 197 #define txtRec ((TXTRecordRefRealType*)txtRecord)
 198
 199 // The opaque storage defined in the public dns_sd.h header is 16 bytes;
 200 // make sure we don't exceed that.
 201 struct dnssd_clientlib_CompileTimeAssertionCheck
 202         {
 203         char assert0[(sizeof(TXTRecordRefRealType) <= 16) ? 1 : -1];
 204         };
 205
 206 void DNSSD_API TXTRecordCreate
 207         (
 208         TXTRecordRef     *txtRecord,
 209         uint16_t         bufferLen,
 210         void             *buffer
 211         )
 212         {
 213         txtRec->buffer   = buffer;
 214         txtRec->buflen   = buffer ? bufferLen : (uint16_t)0;
 215         txtRec->datalen  = 0;
 216         txtRec->malloced = 0;
 217         }
 218
 219 void DNSSD_API TXTRecordDeallocate(TXTRecordRef *txtRecord)
 220         {
 221         if (txtRec->malloced) free(txtRec->buffer);
 222         }
 223
 224 DNSServiceErrorType DNSSD_API TXTRecordSetValue
 225         (
 226         TXTRecordRef     *txtRecord,
 227         const char       *key,
 228         uint8_t          valueSize,
 229         const void       *value
 230         )
 231         {
 232         uint8_t *start, *p;
 233         const char *k;
 234         unsigned long keysize, keyvalsize;
 235
 236         for (k = key; *k; k++) if (*k < 0x20 || *k > 0x7E || *k == '=') return(kDNSServiceErr_Invalid);
 237         keysize = (unsigned long)(k - key);
 238         keyvalsize = 1 + keysize + (value ? (1 + valueSize) : 0);
 239         if (keysize < 1 || keyvalsize > 255) return(kDNSServiceErr_Invalid);
 240         (void)TXTRecordRemoveValue(txtRecord, key);
 241         if (txtRec->datalen + keyvalsize > txtRec->buflen)
 242                 {
 243                 unsigned char *newbuf;
 244                 unsigned long newlen = txtRec->datalen + keyvalsize;
 245                 if (newlen > 0xFFFF) return(kDNSServiceErr_Invalid);
 246                 newbuf = malloc((size_t)newlen);
 247                 if (!newbuf) return(kDNSServiceErr_NoMemory);
 248                 memcpy(newbuf, txtRec->buffer, txtRec->datalen);
 249                 if (txtRec->malloced) free(txtRec->buffer);
 250                 txtRec->buffer = newbuf;
 251                 txtRec->buflen = (uint16_t)(newlen);
 252                 txtRec->malloced = 1;
 253                 }
 254         start = txtRec->buffer + txtRec->datalen;
 255         p = start + 1;
 256         memcpy(p, key, keysize);
 257         p += keysize;
 258         if (value)
 259                 {
 260                 *p++ = '=';
 261                 memcpy(p, value, valueSize);
 262                 p += valueSize;
 263                 }
 264         *start = (uint8_t)(p - start - 1);
 265         txtRec->datalen += p - start;
 266         return(kDNSServiceErr_NoError);
 267         }
 268
 269 DNSServiceErrorType DNSSD_API TXTRecordRemoveValue
 270         (
 271         TXTRecordRef     *txtRecord,
 272         const char       *key
 273         )
 274         {
 275         unsigned long keylen, itemlen, remainder;
 276         uint8_t *item = InternalTXTRecordSearch(txtRec->datalen, txtRec->buffer, key, &keylen);
 277         if (!item) return(kDNSServiceErr_NoSuchKey);
 278         itemlen   = (unsigned long)(1 + item[0]);
 279         remainder = (unsigned long)((txtRec->buffer + txtRec->datalen) - (item + itemlen));
 280         // Use memmove because memcpy behaviour is undefined for overlapping regions
 281         memmove(item, item + itemlen, remainder);
 282         txtRec->datalen -= itemlen;
 283         return(kDNSServiceErr_NoError);
 284         }
 285
 286 uint16_t DNSSD_API TXTRecordGetLength  (const TXTRecordRef *txtRecord) { return(txtRec->datalen); }
 287 const void * DNSSD_API TXTRecordGetBytesPtr(const TXTRecordRef *txtRecord) { return(txtRec->buffer); }
 288
 289 /*********************************************************************************************
 290  *
 291  *   TXT Record Parsing Functions
 292  *
 293  *********************************************************************************************/
 294
 295 int DNSSD_API TXTRecordContainsKey
 296         (
 297         uint16_t         txtLen,
 298         const void       *txtRecord,
 299         const char       *key
 300         )
 301         {
 302         unsigned long keylen;
 303         return (InternalTXTRecordSearch(txtLen, txtRecord, key, &keylen) ? 1 : 0);
 304         }
 305
 306 const void * DNSSD_API TXTRecordGetValuePtr
 307         (
 308         uint16_t         txtLen,
 309         const void       *txtRecord,
 310         const char       *key,
 311         uint8_t          *valueLen
 312         )
 313         {
 314         unsigned long keylen;
 315         uint8_t *item = InternalTXTRecordSearch(txtLen, txtRecord, key, &keylen);
 316         if (!item || item[0] <= keylen) return(NULL);   // If key not found, or found with no value, return NULL
 317         *valueLen = (uint8_t)(item[0] - (keylen + 1));
 318         return (item + 1 + keylen + 1);
 319         }
 320
 321 uint16_t DNSSD_API TXTRecordGetCount
 322         (
 323         uint16_t         txtLen,
 324         const void       *txtRecord
 325         )
 326         {
 327         uint16_t count = 0;
 328         uint8_t *p = (uint8_t*)txtRecord;
 329         uint8_t *e = p + txtLen;
 330         while (p<e) { p += 1 + p[0]; count++; }
 331         return((p>e) ? (uint16_t)0 : count);
 332         }
 333
 334 DNSServiceErrorType DNSSD_API TXTRecordGetItemAtIndex
 335         (
 336         uint16_t         txtLen,
 337         const void       *txtRecord,
 338         uint16_t         index,
 339         uint16_t         keyBufLen,
 340         char             *key,
 341         uint8_t          *valueLen,
 342         const void       **value
 343         )
 344         {
 345         uint16_t count = 0;
 346         uint8_t *p = (uint8_t*)txtRecord;
 347         uint8_t *e = p + txtLen;
 348         while (p<e && count<index) { p += 1 + p[0]; count++; }  // Find requested item
 349         if (p<e && p + 1 + p[0] <= e)   // If valid
 350                 {
 351                 uint8_t *x = p+1;
 352                 unsigned long len = 0;
 353                 e = p + 1 + p[0];
 354                 while (x+len<e && x[len] != '=') len++;
 355                 if (len >= keyBufLen) return(kDNSServiceErr_NoMemory);
 356                 memcpy(key, x, len);
 357                 key[len] = 0;
 358                 if (x+len<e)            // If we found '='
 359                         {
 360                         *value = x + len + 1;
 361                         *valueLen = (uint8_t)(p[0] - (len + 1));
 362                         }
 363                 else
 364                         {
 365                         *value = NULL;
 366                         *valueLen = 0;
 367                         }
 368                 return(kDNSServiceErr_NoError);
 369                 }
 370         return(kDNSServiceErr_Invalid);
 371         }