Home | History | Annotate | Download | only in mDNSShared
      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 
     29 #include <stdlib.h>
     30 #include <string.h>
     31 
     32 #include "dns_sd.h"
     33 
     34 #if MDNS_BUILDINGSHAREDLIBRARY || MDNS_BUILDINGSTUBLIBRARY
     35 #pragma export on
     36 #endif
     37 
     38 #if defined(_WIN32)
     39 // disable warning "conversion from <data> to uint16_t"
     40 #pragma warning(disable:4244)
     41 #define strncasecmp _strnicmp
     42 #define strcasecmp _stricmp
     43 #endif
     44 
     45 /*********************************************************************************************
     46  *
     47  *  Supporting Functions
     48  *
     49  *********************************************************************************************/
     50 
     51 #define mDNSIsDigit(X)     ((X) >= '0' && (X) <= '9')
     52 
     53 // DomainEndsInDot returns 1 if name ends with a dot, 0 otherwise
     54 // (DNSServiceConstructFullName depends this returning 1 for true, rather than any non-zero value meaning true)
     55 
     56 static int DomainEndsInDot(const char *dom)
     57 	{
     58 	while (dom[0] && dom[1])
     59 		{
     60 		if (dom[0] == '\\') // advance past escaped byte sequence
     61 			{
     62 			if (mDNSIsDigit(dom[1]) && mDNSIsDigit(dom[2]) && mDNSIsDigit(dom[3]))
     63 				dom += 4;			// If "\ddd"    then skip four
     64 			else dom += 2;			// else if "\x" then skip two
     65 			}
     66 		else dom++;					// else goto next character
     67 		}
     68 	return (dom[0] == '.');
     69 	}
     70 
     71 static uint8_t *InternalTXTRecordSearch
     72 	(
     73 	uint16_t         txtLen,
     74 	const void       *txtRecord,
     75 	const char       *key,
     76 	unsigned long    *keylen
     77 	)
     78 	{
     79 	uint8_t *p = (uint8_t*)txtRecord;
     80 	uint8_t *e = p + txtLen;
     81 	*keylen = (unsigned long) strlen(key);
     82 	while (p<e)
     83 		{
     84 		uint8_t *x = p;
     85 		p += 1 + p[0];
     86 		if (p <= e && *keylen <= x[0] && !strncasecmp(key, (char*)x+1, *keylen))
     87 			if (*keylen == x[0] || x[1+*keylen] == '=') return(x);
     88 		}
     89 	return(NULL);
     90 	}
     91 
     92 /*********************************************************************************************
     93  *
     94  *  General Utility Functions
     95  *
     96  *********************************************************************************************/
     97 
     98 // Note: Need to make sure we don't write more than kDNSServiceMaxDomainName (1009) bytes to fullName
     99 // In earlier builds this constant was defined to be 1005, so to avoid buffer overruns on clients
    100 // compiled with that constant we'll actually limit the output to 1005 bytes.
    101 
    102 DNSServiceErrorType DNSSD_API DNSServiceConstructFullName
    103 	(
    104 	char       *const fullName,
    105 	const char *const service,      // May be NULL
    106 	const char *const regtype,
    107 	const char *const domain
    108 	)
    109 	{
    110 	const size_t len = !regtype ? 0 : strlen(regtype) - DomainEndsInDot(regtype);
    111 	char       *fn   = fullName;
    112 	char *const lim  = fullName + 1005;
    113 	const char *s    = service;
    114 	const char *r    = regtype;
    115 	const char *d    = domain;
    116 
    117 	// regtype must be at least "x._udp" or "x._tcp"
    118 	if (len < 6 || !domain || !domain[0]) return kDNSServiceErr_BadParam;
    119 	if (strncasecmp((regtype + len - 4), "_tcp", 4) && strncasecmp((regtype + len - 4), "_udp", 4)) return kDNSServiceErr_BadParam;
    120 
    121 	if (service && *service)
    122 		{
    123 		while (*s)
    124 			{
    125 			unsigned char c = *s++;				// Needs to be unsigned, or values like 0xFF will be interpreted as < 32
    126 			if (c <= ' ')						// Escape non-printable characters
    127 				{
    128 				if (fn+4 >= lim) goto fail;
    129 				*fn++ = '\\';
    130 				*fn++ = '0' + (c / 100);
    131 				*fn++ = '0' + (c /  10) % 10;
    132 				c     = '0' + (c      ) % 10;
    133 				}
    134 			else if (c == '.' || (c == '\\'))	// Escape dot and backslash literals
    135 				{
    136 				if (fn+2 >= lim) goto fail;
    137 				*fn++ = '\\';
    138 				}
    139 			else
    140 				if (fn+1 >= lim) goto fail;
    141 			*fn++ = (char)c;
    142 			}
    143 		*fn++ = '.';
    144 		}
    145 
    146 	while (*r) if (fn+1 >= lim) goto fail; else *fn++ = *r++;
    147 	if (!DomainEndsInDot(regtype)) { if (fn+1 >= lim) goto fail; else *fn++ = '.'; }
    148 
    149 	while (*d) if (fn+1 >= lim) goto fail; else *fn++ = *d++;
    150 	if (!DomainEndsInDot(domain)) { if (fn+1 >= lim) goto fail; else *fn++ = '.'; }
    151 
    152 	*fn = '\0';
    153 	return kDNSServiceErr_NoError;
    154 
    155 fail:
    156 	*fn = '\0';
    157 	return kDNSServiceErr_BadParam;
    158 	}
    159 
    160 /*********************************************************************************************
    161  *
    162  *   TXT Record Construction Functions
    163  *
    164  *********************************************************************************************/
    165 
    166 typedef struct _TXTRecordRefRealType
    167 	{
    168 	uint8_t  *buffer;		// Pointer to data
    169 	uint16_t buflen;		// Length of buffer
    170 	uint16_t datalen;		// Length currently in use
    171 	uint16_t malloced;	// Non-zero if buffer was allocated via malloc()
    172 	} TXTRecordRefRealType;
    173 
    174 #define txtRec ((TXTRecordRefRealType*)txtRecord)
    175 
    176 // The opaque storage defined in the public dns_sd.h header is 16 bytes;
    177 // make sure we don't exceed that.
    178 struct CompileTimeAssertionCheck_dnssd_clientlib
    179 	{
    180 	char assert0[(sizeof(TXTRecordRefRealType) <= 16) ? 1 : -1];
    181 	};
    182 
    183 void DNSSD_API TXTRecordCreate
    184 	(
    185 	TXTRecordRef     *txtRecord,
    186 	uint16_t         bufferLen,
    187 	void             *buffer
    188 	)
    189 	{
    190 	txtRec->buffer   = buffer;
    191 	txtRec->buflen   = buffer ? bufferLen : (uint16_t)0;
    192 	txtRec->datalen  = 0;
    193 	txtRec->malloced = 0;
    194 	}
    195 
    196 void DNSSD_API TXTRecordDeallocate(TXTRecordRef *txtRecord)
    197 	{
    198 	if (txtRec->malloced) free(txtRec->buffer);
    199 	}
    200 
    201 DNSServiceErrorType DNSSD_API TXTRecordSetValue
    202 	(
    203 	TXTRecordRef     *txtRecord,
    204 	const char       *key,
    205 	uint8_t          valueSize,
    206 	const void       *value
    207 	)
    208 	{
    209 	uint8_t *start, *p;
    210 	const char *k;
    211 	unsigned long keysize, keyvalsize;
    212 
    213 	for (k = key; *k; k++) if (*k < 0x20 || *k > 0x7E || *k == '=') return(kDNSServiceErr_Invalid);
    214 	keysize = (unsigned long)(k - key);
    215 	keyvalsize = 1 + keysize + (value ? (1 + valueSize) : 0);
    216 	if (keysize < 1 || keyvalsize > 255) return(kDNSServiceErr_Invalid);
    217 	(void)TXTRecordRemoveValue(txtRecord, key);
    218 	if (txtRec->datalen + keyvalsize > txtRec->buflen)
    219 		{
    220 		unsigned char *newbuf;
    221 		unsigned long newlen = txtRec->datalen + keyvalsize;
    222 		if (newlen > 0xFFFF) return(kDNSServiceErr_Invalid);
    223 		newbuf = malloc((size_t)newlen);
    224 		if (!newbuf) return(kDNSServiceErr_NoMemory);
    225 		memcpy(newbuf, txtRec->buffer, txtRec->datalen);
    226 		if (txtRec->malloced) free(txtRec->buffer);
    227 		txtRec->buffer = newbuf;
    228 		txtRec->buflen = (uint16_t)(newlen);
    229 		txtRec->malloced = 1;
    230 		}
    231 	start = txtRec->buffer + txtRec->datalen;
    232 	p = start + 1;
    233 	memcpy(p, key, keysize);
    234 	p += keysize;
    235 	if (value)
    236 		{
    237 		*p++ = '=';
    238 		memcpy(p, value, valueSize);
    239 		p += valueSize;
    240 		}
    241 	*start = (uint8_t)(p - start - 1);
    242 	txtRec->datalen += p - start;
    243 	return(kDNSServiceErr_NoError);
    244 	}
    245 
    246 DNSServiceErrorType DNSSD_API TXTRecordRemoveValue
    247 	(
    248 	TXTRecordRef     *txtRecord,
    249 	const char       *key
    250 	)
    251 	{
    252 	unsigned long keylen, itemlen, remainder;
    253 	uint8_t *item = InternalTXTRecordSearch(txtRec->datalen, txtRec->buffer, key, &keylen);
    254 	if (!item) return(kDNSServiceErr_NoSuchKey);
    255 	itemlen   = (unsigned long)(1 + item[0]);
    256 	remainder = (unsigned long)((txtRec->buffer + txtRec->datalen) - (item + itemlen));
    257 	// Use memmove because memcpy behaviour is undefined for overlapping regions
    258 	memmove(item, item + itemlen, remainder);
    259 	txtRec->datalen -= itemlen;
    260 	return(kDNSServiceErr_NoError);
    261 	}
    262 
    263 uint16_t DNSSD_API TXTRecordGetLength  (const TXTRecordRef *txtRecord) { return(txtRec->datalen); }
    264 const void * DNSSD_API TXTRecordGetBytesPtr(const TXTRecordRef *txtRecord) { return(txtRec->buffer); }
    265 
    266 /*********************************************************************************************
    267  *
    268  *   TXT Record Parsing Functions
    269  *
    270  *********************************************************************************************/
    271 
    272 int DNSSD_API TXTRecordContainsKey
    273 	(
    274 	uint16_t         txtLen,
    275 	const void       *txtRecord,
    276 	const char       *key
    277 	)
    278 	{
    279 	unsigned long keylen;
    280 	return (InternalTXTRecordSearch(txtLen, txtRecord, key, &keylen) ? 1 : 0);
    281 	}
    282 
    283 const void * DNSSD_API TXTRecordGetValuePtr
    284 	(
    285 	uint16_t         txtLen,
    286 	const void       *txtRecord,
    287 	const char       *key,
    288 	uint8_t          *valueLen
    289 	)
    290 	{
    291 	unsigned long keylen;
    292 	uint8_t *item = InternalTXTRecordSearch(txtLen, txtRecord, key, &keylen);
    293 	if (!item || item[0] <= keylen) return(NULL);	// If key not found, or found with no value, return NULL
    294 	*valueLen = (uint8_t)(item[0] - (keylen + 1));
    295 	return (item + 1 + keylen + 1);
    296 	}
    297 
    298 uint16_t DNSSD_API TXTRecordGetCount
    299 	(
    300 	uint16_t         txtLen,
    301 	const void       *txtRecord
    302 	)
    303 	{
    304 	uint16_t count = 0;
    305 	uint8_t *p = (uint8_t*)txtRecord;
    306 	uint8_t *e = p + txtLen;
    307 	while (p<e) { p += 1 + p[0]; count++; }
    308 	return((p>e) ? (uint16_t)0 : count);
    309 	}
    310 
    311 DNSServiceErrorType DNSSD_API TXTRecordGetItemAtIndex
    312 	(
    313 	uint16_t         txtLen,
    314 	const void       *txtRecord,
    315 	uint16_t         itemIndex,
    316 	uint16_t         keyBufLen,
    317 	char             *key,
    318 	uint8_t          *valueLen,
    319 	const void       **value
    320 	)
    321 	{
    322 	uint16_t count = 0;
    323 	uint8_t *p = (uint8_t*)txtRecord;
    324 	uint8_t *e = p + txtLen;
    325 	while (p<e && count<itemIndex) { p += 1 + p[0]; count++; }	// Find requested item
    326 	if (p<e && p + 1 + p[0] <= e)	// If valid
    327 		{
    328 		uint8_t *x = p+1;
    329 		unsigned long len = 0;
    330 		e = p + 1 + p[0];
    331 		while (x+len<e && x[len] != '=') len++;
    332 		if (len >= keyBufLen) return(kDNSServiceErr_NoMemory);
    333 		memcpy(key, x, len);
    334 		key[len] = 0;
    335 		if (x+len<e)		// If we found '='
    336 			{
    337 			*value = x + len + 1;
    338 			*valueLen = (uint8_t)(p[0] - (len + 1));
    339 			}
    340 		else
    341 			{
    342 			*value = NULL;
    343 			*valueLen = 0;
    344 			}
    345 		return(kDNSServiceErr_NoError);
    346 		}
    347 	return(kDNSServiceErr_Invalid);
    348 	}
    349 
    350 /*********************************************************************************************
    351  *
    352  *   SCCS-compatible version string
    353  *
    354  *********************************************************************************************/
    355 
    356 // For convenience when using the "strings" command, this is the last thing in the file
    357 
    358 // Note: The C preprocessor stringify operator ('#') makes a string from its argument, without macro expansion
    359 // e.g. If "version" is #define'd to be "4", then STRINGIFY_AWE(version) will return the string "version", not "4"
    360 // To expand "version" to its value before making the string, use STRINGIFY(version) instead
    361 #define STRINGIFY_ARGUMENT_WITHOUT_EXPANSION(s) #s
    362 #define STRINGIFY(s) STRINGIFY_ARGUMENT_WITHOUT_EXPANSION(s)
    363 
    364 // NOT static -- otherwise the compiler may optimize it out
    365 // The "@(#) " pattern is a special prefix the "what" command looks for
    366 const char VersionString_SCCS_libdnssd[] = "@(#) libdns_sd " STRINGIFY(mDNSResponderVersion) " (" __DATE__ " " __TIME__ ")";
    367