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
56static 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
71static 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
102DNSServiceErrorType 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
155fail:
156	*fn = '\0';
157	return kDNSServiceErr_BadParam;
158	}
159
160/*********************************************************************************************
161 *
162 *   TXT Record Construction Functions
163 *
164 *********************************************************************************************/
165
166typedef 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.
178struct CompileTimeAssertionCheck_dnssd_clientlib
179	{
180	char assert0[(sizeof(TXTRecordRefRealType) <= 16) ? 1 : -1];
181	};
182
183void 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
196void DNSSD_API TXTRecordDeallocate(TXTRecordRef *txtRecord)
197	{
198	if (txtRec->malloced) free(txtRec->buffer);
199	}
200
201DNSServiceErrorType 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
246DNSServiceErrorType 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
263uint16_t DNSSD_API TXTRecordGetLength  (const TXTRecordRef *txtRecord) { return(txtRec->datalen); }
264const void * DNSSD_API TXTRecordGetBytesPtr(const TXTRecordRef *txtRecord) { return(txtRec->buffer); }
265
266/*********************************************************************************************
267 *
268 *   TXT Record Parsing Functions
269 *
270 *********************************************************************************************/
271
272int 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
283const 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
298uint16_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
311DNSServiceErrorType 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
366const char VersionString_SCCS_libdnssd[] = "@(#) libdns_sd " STRINGIFY(mDNSResponderVersion) " (" __DATE__ " " __TIME__ ")";
367