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__ ")";