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
