You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
369 lines
12 KiB
369 lines
12 KiB
/* -*- Mode: C; tab-width: 4 -*-
|
|
*
|
|
* Copyright (c) 2004, Apple Computer, Inc. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of its
|
|
* contributors may be used to endorse or promote products derived from this
|
|
* software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "dns_sd.h"
|
|
|
|
#if MDNS_BUILDINGSHAREDLIBRARY || MDNS_BUILDINGSTUBLIBRARY
|
|
#pragma export on
|
|
#endif
|
|
|
|
#if defined(_WIN32)
|
|
// disable warning "conversion from <data> to uint16_t"
|
|
#pragma warning(disable:4244)
|
|
#define strncasecmp _strnicmp
|
|
#define strcasecmp _stricmp
|
|
#endif
|
|
|
|
/*********************************************************************************************
|
|
*
|
|
* Supporting Functions
|
|
*
|
|
*********************************************************************************************/
|
|
|
|
#define mDNSIsDigit(X) ((X) >= '0' && (X) <= '9')
|
|
|
|
// DomainEndsInDot returns 1 if name ends with a dot, 0 otherwise
|
|
// (DNSServiceConstructFullName depends this returning 1 for true, rather than any non-zero value meaning true)
|
|
|
|
static int DomainEndsInDot(const char *dom)
|
|
{
|
|
while (dom[0] && dom[1])
|
|
{
|
|
if (dom[0] == '\\') // advance past escaped byte sequence
|
|
{
|
|
if (mDNSIsDigit(dom[1]) && mDNSIsDigit(dom[2]) && mDNSIsDigit(dom[3]))
|
|
dom += 4; // If "\ddd" then skip four
|
|
else dom += 2; // else if "\x" then skip two
|
|
}
|
|
else dom++; // else goto next character
|
|
}
|
|
return (dom[0] == '.');
|
|
}
|
|
|
|
static uint8_t *InternalTXTRecordSearch
|
|
(
|
|
uint16_t txtLen,
|
|
const void *txtRecord,
|
|
const char *key,
|
|
unsigned long *keylen
|
|
)
|
|
{
|
|
uint8_t *p = (uint8_t*)txtRecord;
|
|
uint8_t *e = p + txtLen;
|
|
*keylen = (unsigned long) strlen(key);
|
|
while (p<e)
|
|
{
|
|
uint8_t *x = p;
|
|
p += 1 + p[0];
|
|
if (p <= e && *keylen <= x[0] && !strncasecmp(key, (char*)x+1, *keylen))
|
|
if (*keylen == x[0] || x[1+*keylen] == '=') return(x);
|
|
}
|
|
return(NULL);
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
*
|
|
* General Utility Functions
|
|
*
|
|
*********************************************************************************************/
|
|
|
|
// Note: Need to make sure we don't write more than kDNSServiceMaxDomainName (1009) bytes to fullName
|
|
// In earlier builds this constant was defined to be 1005, so to avoid buffer overruns on clients
|
|
// compiled with that constant we'll actually limit the output to 1005 bytes.
|
|
|
|
DNSServiceErrorType DNSSD_API DNSServiceConstructFullName
|
|
(
|
|
char *const fullName,
|
|
const char *const service, // May be NULL
|
|
const char *const regtype,
|
|
const char *const domain
|
|
)
|
|
{
|
|
const size_t len = !regtype ? 0 : strlen(regtype) - DomainEndsInDot(regtype);
|
|
char *fn = fullName;
|
|
char *const lim = fullName + 1005;
|
|
const char *s = service;
|
|
const char *r = regtype;
|
|
const char *d = domain;
|
|
|
|
// regtype must be at least "x._udp" or "x._tcp"
|
|
if (len < 6 || !domain || !domain[0]) return kDNSServiceErr_BadParam;
|
|
if (strncasecmp((regtype + len - 4), "_tcp", 4) && strncasecmp((regtype + len - 4), "_udp", 4)) return kDNSServiceErr_BadParam;
|
|
|
|
if (service && *service)
|
|
{
|
|
while (*s)
|
|
{
|
|
unsigned char c = *s++; // Needs to be unsigned, or values like 0xFF will be interpreted as < 32
|
|
if (c <= ' ') // Escape non-printable characters
|
|
{
|
|
if (fn+4 >= lim) goto fail;
|
|
*fn++ = '\\';
|
|
*fn++ = '0' + (c / 100);
|
|
*fn++ = '0' + (c / 10) % 10;
|
|
c = '0' + (c ) % 10;
|
|
}
|
|
else if (c == '.' || (c == '\\')) // Escape dot and backslash literals
|
|
{
|
|
if (fn+2 >= lim) goto fail;
|
|
*fn++ = '\\';
|
|
}
|
|
else
|
|
if (fn+1 >= lim) goto fail;
|
|
*fn++ = (char)c;
|
|
}
|
|
*fn++ = '.';
|
|
}
|
|
|
|
while (*r) if (fn+1 >= lim) goto fail; else *fn++ = *r++;
|
|
if (!DomainEndsInDot(regtype)) { if (fn+1 >= lim) goto fail; else *fn++ = '.'; }
|
|
|
|
while (*d) if (fn+1 >= lim) goto fail; else *fn++ = *d++;
|
|
if (!DomainEndsInDot(domain)) { if (fn+1 >= lim) goto fail; else *fn++ = '.'; }
|
|
|
|
*fn = '\0';
|
|
return kDNSServiceErr_NoError;
|
|
|
|
fail:
|
|
*fn = '\0';
|
|
return kDNSServiceErr_BadParam;
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
*
|
|
* TXT Record Construction Functions
|
|
*
|
|
*********************************************************************************************/
|
|
|
|
typedef struct _TXTRecordRefRealType
|
|
{
|
|
uint8_t *buffer; // Pointer to data
|
|
uint16_t buflen; // Length of buffer
|
|
uint16_t datalen; // Length currently in use
|
|
uint16_t malloced; // Non-zero if buffer was allocated via malloc()
|
|
} TXTRecordRefRealType;
|
|
|
|
#define txtRec ((TXTRecordRefRealType*)txtRecord)
|
|
|
|
// The opaque storage defined in the public dns_sd.h header is 16 bytes;
|
|
// make sure we don't exceed that.
|
|
struct CompileTimeAssertionCheck_dnssd_clientlib
|
|
{
|
|
char assert0[(sizeof(TXTRecordRefRealType) <= 16) ? 1 : -1];
|
|
};
|
|
|
|
void DNSSD_API TXTRecordCreate
|
|
(
|
|
TXTRecordRef *txtRecord,
|
|
uint16_t bufferLen,
|
|
void *buffer
|
|
)
|
|
{
|
|
txtRec->buffer = buffer;
|
|
txtRec->buflen = buffer ? bufferLen : (uint16_t)0;
|
|
txtRec->datalen = 0;
|
|
txtRec->malloced = 0;
|
|
}
|
|
|
|
void DNSSD_API TXTRecordDeallocate(TXTRecordRef *txtRecord)
|
|
{
|
|
if (txtRec->malloced) free(txtRec->buffer);
|
|
}
|
|
|
|
DNSServiceErrorType DNSSD_API TXTRecordSetValue
|
|
(
|
|
TXTRecordRef *txtRecord,
|
|
const char *key,
|
|
uint8_t valueSize,
|
|
const void *value
|
|
)
|
|
{
|
|
uint8_t *start, *p;
|
|
const char *k;
|
|
unsigned long keysize, keyvalsize;
|
|
|
|
for (k = key; *k; k++) if (*k < 0x20 || *k > 0x7E || *k == '=') return(kDNSServiceErr_Invalid);
|
|
keysize = (unsigned long)(k - key);
|
|
keyvalsize = 1 + keysize + (value ? (1 + valueSize) : 0);
|
|
if (keysize < 1 || keyvalsize > 255) return(kDNSServiceErr_Invalid);
|
|
(void)TXTRecordRemoveValue(txtRecord, key);
|
|
if (txtRec->datalen + keyvalsize > txtRec->buflen)
|
|
{
|
|
unsigned char *newbuf;
|
|
unsigned long newlen = txtRec->datalen + keyvalsize;
|
|
if (newlen > 0xFFFF) return(kDNSServiceErr_Invalid);
|
|
newbuf = malloc((size_t)newlen);
|
|
if (!newbuf) return(kDNSServiceErr_NoMemory);
|
|
memcpy(newbuf, txtRec->buffer, txtRec->datalen);
|
|
if (txtRec->malloced) free(txtRec->buffer);
|
|
txtRec->buffer = newbuf;
|
|
txtRec->buflen = (uint16_t)(newlen);
|
|
txtRec->malloced = 1;
|
|
}
|
|
start = txtRec->buffer + txtRec->datalen;
|
|
p = start + 1;
|
|
memcpy(p, key, keysize);
|
|
p += keysize;
|
|
if (value)
|
|
{
|
|
*p++ = '=';
|
|
memcpy(p, value, valueSize);
|
|
p += valueSize;
|
|
}
|
|
*start = (uint8_t)(p - start - 1);
|
|
txtRec->datalen += p - start;
|
|
return(kDNSServiceErr_NoError);
|
|
}
|
|
|
|
DNSServiceErrorType DNSSD_API TXTRecordRemoveValue
|
|
(
|
|
TXTRecordRef *txtRecord,
|
|
const char *key
|
|
)
|
|
{
|
|
unsigned long keylen, itemlen, remainder;
|
|
uint8_t *item = InternalTXTRecordSearch(txtRec->datalen, txtRec->buffer, key, &keylen);
|
|
if (!item) return(kDNSServiceErr_NoSuchKey);
|
|
itemlen = (unsigned long)(1 + item[0]);
|
|
remainder = (unsigned long)((txtRec->buffer + txtRec->datalen) - (item + itemlen));
|
|
// Use memmove because memcpy behaviour is undefined for overlapping regions
|
|
memmove(item, item + itemlen, remainder);
|
|
txtRec->datalen -= itemlen;
|
|
return(kDNSServiceErr_NoError);
|
|
}
|
|
|
|
uint16_t DNSSD_API TXTRecordGetLength (const TXTRecordRef *txtRecord) { return(txtRec->datalen); }
|
|
const void * DNSSD_API TXTRecordGetBytesPtr(const TXTRecordRef *txtRecord) { return(txtRec->buffer); }
|
|
|
|
/*********************************************************************************************
|
|
*
|
|
* TXT Record Parsing Functions
|
|
*
|
|
*********************************************************************************************/
|
|
|
|
int DNSSD_API TXTRecordContainsKey
|
|
(
|
|
uint16_t txtLen,
|
|
const void *txtRecord,
|
|
const char *key
|
|
)
|
|
{
|
|
unsigned long keylen;
|
|
return (InternalTXTRecordSearch(txtLen, txtRecord, key, &keylen) ? 1 : 0);
|
|
}
|
|
|
|
const void * DNSSD_API TXTRecordGetValuePtr
|
|
(
|
|
uint16_t txtLen,
|
|
const void *txtRecord,
|
|
const char *key,
|
|
uint8_t *valueLen
|
|
)
|
|
{
|
|
unsigned long keylen;
|
|
uint8_t *item = InternalTXTRecordSearch(txtLen, txtRecord, key, &keylen);
|
|
if (!item || item[0] <= keylen) return(NULL); // If key not found, or found with no value, return NULL
|
|
*valueLen = (uint8_t)(item[0] - (keylen + 1));
|
|
return (item + 1 + keylen + 1);
|
|
}
|
|
|
|
uint16_t DNSSD_API TXTRecordGetCount
|
|
(
|
|
uint16_t txtLen,
|
|
const void *txtRecord
|
|
)
|
|
{
|
|
uint16_t count = 0;
|
|
uint8_t *p = (uint8_t*)txtRecord;
|
|
uint8_t *e = p + txtLen;
|
|
while (p<e) { p += 1 + p[0]; count++; }
|
|
return((p>e) ? (uint16_t)0 : count);
|
|
}
|
|
|
|
DNSServiceErrorType DNSSD_API TXTRecordGetItemAtIndex
|
|
(
|
|
uint16_t txtLen,
|
|
const void *txtRecord,
|
|
uint16_t itemIndex,
|
|
uint16_t keyBufLen,
|
|
char *key,
|
|
uint8_t *valueLen,
|
|
const void **value
|
|
)
|
|
{
|
|
uint16_t count = 0;
|
|
uint8_t *p = (uint8_t*)txtRecord;
|
|
uint8_t *e = p + txtLen;
|
|
while (p<e && count<itemIndex) { p += 1 + p[0]; count++; } // Find requested item
|
|
if (p<e && p + 1 + p[0] <= e) // If valid
|
|
{
|
|
uint8_t *x = p+1;
|
|
unsigned long len = 0;
|
|
e = p + 1 + p[0];
|
|
while (x+len<e && x[len] != '=') len++;
|
|
if (len >= keyBufLen) return(kDNSServiceErr_NoMemory);
|
|
memcpy(key, x, len);
|
|
key[len] = 0;
|
|
if (x+len<e) // If we found '='
|
|
{
|
|
*value = x + len + 1;
|
|
*valueLen = (uint8_t)(p[0] - (len + 1));
|
|
}
|
|
else
|
|
{
|
|
*value = NULL;
|
|
*valueLen = 0;
|
|
}
|
|
return(kDNSServiceErr_NoError);
|
|
}
|
|
return(kDNSServiceErr_Invalid);
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
*
|
|
* SCCS-compatible version string
|
|
*
|
|
*********************************************************************************************/
|
|
|
|
// For convenience when using the "strings" command, this is the last thing in the file
|
|
|
|
// Note: The C preprocessor stringify operator ('#') makes a string from its argument, without macro expansion
|
|
// e.g. If "version" is #define'd to be "4", then STRINGIFY_AWE(version) will return the string "version", not "4"
|
|
// To expand "version" to its value before making the string, use STRINGIFY(version) instead
|
|
#define STRINGIFY_ARGUMENT_WITHOUT_EXPANSION(s) #s
|
|
#define STRINGIFY(s) STRINGIFY_ARGUMENT_WITHOUT_EXPANSION(s)
|
|
|
|
// NOT static -- otherwise the compiler may optimize it out
|
|
// The "@(#) " pattern is a special prefix the "what" command looks for
|
|
#ifndef ANDROID
|
|
const char VersionString_SCCS_libdnssd[] = "@(#) libdns_sd " STRINGIFY(mDNSResponderVersion) " (" __DATE__ " " __TIME__ ")";
|
|
#endif
|