[apple/configd.git] / dnsinfo / dnsinfo_create.c

/*
 * Copyright (c) 2004, 2006, 2009 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */

#include <stdlib.h>
#include <strings.h>
#include <mach/mach.h>
#include <mach/mach_error.h>

#include "dnsinfo_create.h"
#include "dnsinfo_private.h"
#include "shared_dns_info.h"


#define ROUNDUP(a, size) \
	(((a) & ((size)-1)) ? (1 + ((a) | ((size)-1))) : (a))


/*
 * to avoid extra calls to realloc() we want to pre-allocate the initial
 * resolver and configuration buffers of a sufficient size that they would
 * not normally need to be expanded.
 */
#define INITIAL_CONFIGURATION_BUF_SIZE  8192
#define INITIAL_RESOLVER_BUF_SIZE       1024


/*
 * DNS [configuration] buffer functions
 */


dns_create_config_t
_dns_configuration_create()
{
	_dns_config_buf_t	*config;

	config = calloc(1, INITIAL_CONFIGURATION_BUF_SIZE);
//	config->n_attribute = 0;
//	config->n_padding = 0;
	return (dns_create_config_t)config;
}


static void
config_add_attribute(dns_create_config_t	*_config,
		     uint32_t			attribute_type,
		     uint32_t			attribute_length,
		     void			*attribute,
		     uint32_t			extra_padding)
{
	_dns_config_buf_t	*config	= (_dns_config_buf_t *)*_config;
	dns_attribute_t		*header;
	int			i;
	uint32_t		newLen;
	uint32_t		newSize;
	uint32_t		oldLen;
	uint32_t		rounded_length;

	// add space

	oldLen         = ntohl(config->n_attribute);
	rounded_length = ROUNDUP(attribute_length, sizeof(uint32_t));
	newLen         = sizeof(dns_attribute_t) + rounded_length;
	newSize = sizeof(_dns_config_buf_t) + oldLen + newLen;
	if (newSize > INITIAL_CONFIGURATION_BUF_SIZE) {
		config = realloc(config, newSize);
	}
	config->n_attribute = htonl(ntohl(config->n_attribute) + newLen);

	// increment additional padding that will be needed (later)
	config->n_padding = htonl(ntohl(config->n_padding) + extra_padding);

	// add attribute [header]

	header = (dns_attribute_t *)&config->attribute[oldLen];
	header->type   = htonl(attribute_type);
	header->length = htonl(newLen);

	// add attribute [data]

	bcopy(attribute, &header->attribute[0], attribute_length);
	for (i = attribute_length; i < rounded_length; i++) {
		header->attribute[i] = 0;
	}

	*_config = (dns_create_config_t)config;
	return;
}


void
_dns_configuration_add_resolver(dns_create_config_t     *_config,
				dns_create_resolver_t	_resolver)
{
	_dns_config_buf_t	*config		= (_dns_config_buf_t *)*_config;
	uint32_t		padding		= 0;
	_dns_resolver_buf_t	*resolver	= (_dns_resolver_buf_t *)_resolver;

	/*
	 * compute the amount of space that will be needed for
	 * pointers to the resolver, the nameservers, the search
	 * list, and the sortaddr list.
	 */
	padding += sizeof(DNS_PTR(dns_resolver_t *, x));
	if (resolver->resolver.n_nameserver != 0) {
		padding += ntohl(resolver->resolver.n_nameserver) * sizeof(DNS_PTR(struct sockaddr *, x));
	}
	if (resolver->resolver.n_search != 0) {
		padding += ntohl(resolver->resolver.n_search) * sizeof(DNS_PTR(char *, x));
	}
	if (resolver->resolver.n_sortaddr != 0) {
		padding += ntohl(resolver->resolver.n_sortaddr) * sizeof(DNS_PTR(dns_sortaddr_t *, x));
	}

	config->config.n_resolver = htonl(ntohl(config->config.n_resolver) + 1);

	config_add_attribute(_config,
			     CONFIG_ATTRIBUTE_RESOLVER,
			     sizeof(_dns_resolver_buf_t) + ntohl(resolver->n_attribute),
			     (void *)resolver,
			     padding);

	return;
}


_Bool
_dns_configuration_store(dns_create_config_t *_config)
{
	dnsDataOut_t		dataRef	= NULL;
	mach_msg_type_number_t	dataLen	= 0;
	mach_port_t		server;
	kern_return_t		status;

	server = _dns_configuration_server_port();
	if (server == MACH_PORT_NULL) {
		return FALSE;
	}

	if (_config != NULL) {
		_dns_config_buf_t	*config	= (_dns_config_buf_t *)*_config;

		if (config != NULL) {
			dataRef = (dnsDataOut_t)config;
			dataLen = sizeof(_dns_config_buf_t) + ntohl(config->n_attribute);
		}
	}

	status = shared_dns_infoSet(server, dataRef, dataLen);
	(void) mach_port_deallocate(mach_task_self(), server);
	if (status != KERN_SUCCESS) {
		mach_error("shared_dns_infoSet():", status);
		return FALSE;
	}

	return TRUE;
}


void
_dns_configuration_free(dns_create_config_t *_config)
{
	_dns_config_buf_t	*config	= (_dns_config_buf_t *)*_config;

	free(config);
	*_config = NULL;
	return;
}


/*
 * DNS resolver configuration functions
 */

dns_create_resolver_t
_dns_resolver_create()
{
	_dns_resolver_buf_t	*buf;

	buf = calloc(1, INITIAL_RESOLVER_BUF_SIZE);
//	buf->n_attribute = 0;
	return (dns_create_resolver_t)buf;
}


static void
_dns_resolver_add_attribute(dns_create_resolver_t	*_resolver,
			    uint32_t			attribute_type,
			    uint32_t			attribute_length,
			    void			*attribute)
{
	dns_attribute_t		*header;
	int			i;
	uint32_t		newLen;
	uint32_t		newSize;
	uint32_t		oldLen;
	_dns_resolver_buf_t	*resolver	= (_dns_resolver_buf_t *)*_resolver;
	uint32_t		rounded_length;

	// add space

	oldLen         = ntohl(resolver->n_attribute);
	rounded_length = ROUNDUP(attribute_length, sizeof(uint32_t));
	newLen         = sizeof(dns_attribute_t) + rounded_length;
	newSize = sizeof(_dns_resolver_buf_t) + oldLen + newLen;
	if (newSize > INITIAL_RESOLVER_BUF_SIZE) {
		resolver = realloc(resolver, newSize);
	}
	resolver->n_attribute = htonl(ntohl(resolver->n_attribute) + newLen);

	// add attribute [header]

	header = (dns_attribute_t *)&resolver->attribute[oldLen];
	header->type   = htonl(attribute_type);
	header->length = htonl(newLen);

	// add attribute [data]

	bcopy(attribute, &header->attribute[0], attribute_length);
	for (i = attribute_length; i < rounded_length; i++) {
		header->attribute[i] = 0;
	}

	*_resolver = (dns_create_resolver_t)resolver;
	return;
}


void
_dns_resolver_set_domain(dns_create_resolver_t *_resolver, const char *domain)
{
	_dns_resolver_add_attribute(_resolver, RESOLVER_ATTRIBUTE_DOMAIN, strlen(domain) + 1, (void *)domain);
	return;
}


void
_dns_resolver_add_nameserver(dns_create_resolver_t *_resolver, struct sockaddr *nameserver)
{
	_dns_resolver_buf_t	*resolver	= (_dns_resolver_buf_t *)*_resolver;

	resolver->resolver.n_nameserver = htonl(ntohl(resolver->resolver.n_nameserver) + 1);
	_dns_resolver_add_attribute(_resolver, RESOLVER_ATTRIBUTE_ADDRESS, nameserver->sa_len, (void *)nameserver);
	return;
}


void
_dns_resolver_set_port(dns_create_resolver_t *_resolver, uint16_t port)
{
	_dns_resolver_buf_t	*resolver	= (_dns_resolver_buf_t *)*_resolver;

	resolver->resolver.port = htons(port);
	return;
}


void
_dns_resolver_add_search(dns_create_resolver_t *_resolver, const char *search)
{
	_dns_resolver_buf_t	*resolver	= (_dns_resolver_buf_t *)*_resolver;

	resolver->resolver.n_search = htonl(ntohl(resolver->resolver.n_search) + 1);
	_dns_resolver_add_attribute(_resolver, RESOLVER_ATTRIBUTE_SEARCH, strlen(search) + 1, (void *)search);
	return;
}


void
_dns_resolver_add_sortaddr(dns_create_resolver_t *_resolver, dns_sortaddr_t *sortaddr)
{
	_dns_resolver_buf_t	*resolver	= (_dns_resolver_buf_t *)*_resolver;

	resolver->resolver.n_sortaddr = htonl(ntohl(resolver->resolver.n_sortaddr) + 1);
	_dns_resolver_add_attribute(_resolver, RESOLVER_ATTRIBUTE_SORTADDR, sizeof(dns_sortaddr_t), (void *)sortaddr);
	return;
}


void
_dns_resolver_set_options(dns_create_resolver_t *_resolver, const char *options)
{
	_dns_resolver_add_attribute(_resolver, RESOLVER_ATTRIBUTE_OPTIONS, strlen(options) + 1, (void *)options);
	return;
}


void
_dns_resolver_set_timeout(dns_create_resolver_t *_resolver, uint32_t timeout)
{
	_dns_resolver_buf_t	*resolver	= (_dns_resolver_buf_t *)*_resolver;

	resolver->resolver.timeout = htonl(timeout);
	return;
}


void
_dns_resolver_set_order(dns_create_resolver_t *_resolver, uint32_t order)
{
	_dns_resolver_buf_t	*resolver	= (_dns_resolver_buf_t *)*_resolver;

	resolver->resolver.search_order = htonl(order);
	return;
}


void
_dns_resolver_free(dns_create_resolver_t *_resolver)
{
	_dns_resolver_buf_t	*resolver	= (_dns_resolver_buf_t *)*_resolver;

	free(resolver);
	*_resolver = NULL;
	return;
}
Commit	Line	Data
dbf6a266	1	/*
a40a14f8	2	* Copyright (c) 2004, 2006, 2009 Apple Inc. All rights reserved.
dbf6a266 A	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. Please obtain a copy of the License at
	10	* http://www.opensource.apple.com/apsl/ and read it before using this
	11	* file.
	12	*
	13	* The Original Code and all software distributed under the License are
	14	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	15	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	16	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	18	* Please see the License for the specific language governing rights and
	19	* limitations under the License.
	20	*
	21	* @APPLE_LICENSE_HEADER_END@
	22	*/
	23
	24	#include <stdlib.h>
	25	#include <strings.h>
	26	#include <mach/mach.h>
	27	#include <mach/mach_error.h>
	28
	29	#include "dnsinfo_create.h"
	30	#include "dnsinfo_private.h"
	31	#include "shared_dns_info.h"
	32
	33
	34	#define ROUNDUP(a, size) \
	35	(((a) & ((size)-1)) ? (1 + ((a) \| ((size)-1))) : (a))
	36
	37
	38	/*
	39	* to avoid extra calls to realloc() we want to pre-allocate the initial
	40	* resolver and configuration buffers of a sufficient size that they would
	41	* not normally need to be expanded.
	42	*/
	43	#define INITIAL_CONFIGURATION_BUF_SIZE 8192
	44	#define INITIAL_RESOLVER_BUF_SIZE 1024
	45
	46
	47	/*
	48	* DNS [configuration] buffer functions
	49	*/
	50
	51
dbf6a266 A	52	dns_create_config_t
	53	_dns_configuration_create()
	54	{
	55	_dns_config_buf_t *config;
	56
	57	config = calloc(1, INITIAL_CONFIGURATION_BUF_SIZE);
	58	// config->n_attribute = 0;
	59	// config->n_padding = 0;
	60	return (dns_create_config_t)config;
	61	}
	62
	63
	64	static void
	65	config_add_attribute(dns_create_config_t *_config,
	66	uint32_t attribute_type,
	67	uint32_t attribute_length,
	68	void *attribute,
	69	uint32_t extra_padding)
	70	{
	71	_dns_config_buf_t config = (_dns_config_buf_t )*_config;
	72	dns_attribute_t *header;
	73	int i;
	74	uint32_t newLen;
	75	uint32_t newSize;
	76	uint32_t oldLen;
	77	uint32_t rounded_length;
	78
	79	// add space
	80
	81	oldLen = ntohl(config->n_attribute);
	82	rounded_length = ROUNDUP(attribute_length, sizeof(uint32_t));
	83	newLen = sizeof(dns_attribute_t) + rounded_length;
	84	newSize = sizeof(_dns_config_buf_t) + oldLen + newLen;
	85	if (newSize > INITIAL_CONFIGURATION_BUF_SIZE) {
	86	config = realloc(config, newSize);
	87	}
	88	config->n_attribute = htonl(ntohl(config->n_attribute) + newLen);
	89
	90	// increment additional padding that will be needed (later)
	91	config->n_padding = htonl(ntohl(config->n_padding) + extra_padding);
	92
	93	// add attribute [header]
	94
	95	header = (dns_attribute_t *)&config->attribute[oldLen];
	96	header->type = htonl(attribute_type);
	97	header->length = htonl(newLen);
	98
	99	// add attribute [data]
	100
	101	bcopy(attribute, &header->attribute[0], attribute_length);
	102	for (i = attribute_length; i < rounded_length; i++) {
	103	header->attribute[i] = 0;
	104	}
	105
	106	*_config = (dns_create_config_t)config;
	107	return;
	108	}
	109
	110
dbf6a266 A	111	void
	112	_dns_configuration_add_resolver(dns_create_config_t *_config,
	113	dns_create_resolver_t _resolver)
	114	{
	115	_dns_config_buf_t config = (_dns_config_buf_t )*_config;
	116	uint32_t padding = 0;
	117	_dns_resolver_buf_t resolver = (_dns_resolver_buf_t )_resolver;
	118
	119	/*
	120	* compute the amount of space that will be needed for
	121	* pointers to the resolver, the nameservers, the search
	122	* list, and the sortaddr list.
	123	*/
edebe297	124	padding += sizeof(DNS_PTR(dns_resolver_t *, x));
dbf6a266	125	if (resolver->resolver.n_nameserver != 0) {
edebe297	126	padding += ntohl(resolver->resolver.n_nameserver) * sizeof(DNS_PTR(struct sockaddr *, x));
dbf6a266 A	127	}
dbf6a266 A	128	if (resolver->resolver.n_search != 0) {
edebe297	129	padding += ntohl(resolver->resolver.n_search) * sizeof(DNS_PTR(char *, x));
dbf6a266 A	130	}
dbf6a266 A	131	if (resolver->resolver.n_sortaddr != 0) {
edebe297	132	padding += ntohl(resolver->resolver.n_sortaddr) * sizeof(DNS_PTR(dns_sortaddr_t *, x));
dbf6a266 A	133	}
	134
	135	config->config.n_resolver = htonl(ntohl(config->config.n_resolver) + 1);
	136
	137	config_add_attribute(_config,
	138	CONFIG_ATTRIBUTE_RESOLVER,
	139	sizeof(_dns_resolver_buf_t) + ntohl(resolver->n_attribute),
	140	(void *)resolver,
	141	padding);
	142
	143	return;
	144	}
	145
	146
dbf6a266 A	147	_Bool
	148	_dns_configuration_store(dns_create_config_t *_config)
	149	{
	150	dnsDataOut_t dataRef = NULL;
	151	mach_msg_type_number_t dataLen = 0;
	152	mach_port_t server;
	153	kern_return_t status;
	154
	155	server = _dns_configuration_server_port();
	156	if (server == MACH_PORT_NULL) {
	157	return FALSE;
	158	}
	159
	160	if (_config != NULL) {
	161	_dns_config_buf_t config = (_dns_config_buf_t )*_config;
	162
	163	if (config != NULL) {
	164	dataRef = (dnsDataOut_t)config;
	165	dataLen = sizeof(_dns_config_buf_t) + ntohl(config->n_attribute);
	166	}
	167	}
	168
	169	status = shared_dns_infoSet(server, dataRef, dataLen);
edebe297	170	(void) mach_port_deallocate(mach_task_self(), server);
dbf6a266 A	171	if (status != KERN_SUCCESS) {
	172	mach_error("shared_dns_infoSet():", status);
	173	return FALSE;
	174	}
	175
	176	return TRUE;
	177	}
	178
	179
dbf6a266 A	180	void
	181	_dns_configuration_free(dns_create_config_t *_config)
	182	{
	183	_dns_config_buf_t config = (_dns_config_buf_t )*_config;
	184
	185	free(config);
	186	*_config = NULL;
	187	return;
	188	}
	189
	190
	191	/*
	192	* DNS resolver configuration functions
	193	*/
	194
dbf6a266 A	195	dns_create_resolver_t
	196	_dns_resolver_create()
	197	{
	198	_dns_resolver_buf_t *buf;
	199
	200	buf = calloc(1, INITIAL_RESOLVER_BUF_SIZE);
	201	// buf->n_attribute = 0;
	202	return (dns_create_resolver_t)buf;
	203	}
	204
	205
	206	static void
	207	_dns_resolver_add_attribute(dns_create_resolver_t *_resolver,
	208	uint32_t attribute_type,
	209	uint32_t attribute_length,
	210	void *attribute)
	211	{
	212	dns_attribute_t *header;
	213	int i;
	214	uint32_t newLen;
	215	uint32_t newSize;
	216	uint32_t oldLen;
	217	_dns_resolver_buf_t resolver = (_dns_resolver_buf_t )*_resolver;
	218	uint32_t rounded_length;
	219
	220	// add space
	221
	222	oldLen = ntohl(resolver->n_attribute);
	223	rounded_length = ROUNDUP(attribute_length, sizeof(uint32_t));
	224	newLen = sizeof(dns_attribute_t) + rounded_length;
	225	newSize = sizeof(_dns_resolver_buf_t) + oldLen + newLen;
	226	if (newSize > INITIAL_RESOLVER_BUF_SIZE) {
	227	resolver = realloc(resolver, newSize);
	228	}
	229	resolver->n_attribute = htonl(ntohl(resolver->n_attribute) + newLen);
	230
	231	// add attribute [header]
	232
	233	header = (dns_attribute_t *)&resolver->attribute[oldLen];
	234	header->type = htonl(attribute_type);
	235	header->length = htonl(newLen);
	236
	237	// add attribute [data]
	238
	239	bcopy(attribute, &header->attribute[0], attribute_length);
	240	for (i = attribute_length; i < rounded_length; i++) {
	241	header->attribute[i] = 0;
	242	}
	243
	244	*_resolver = (dns_create_resolver_t)resolver;
	245	return;
	246	}
	247
	248
dbf6a266 A	249	void
	250	_dns_resolver_set_domain(dns_create_resolver_t _resolver, const char domain)
	251	{
	252	_dns_resolver_add_attribute(_resolver, RESOLVER_ATTRIBUTE_DOMAIN, strlen(domain) + 1, (void *)domain);
	253	return;
	254	}
	255
	256
dbf6a266 A	257	void
	258	_dns_resolver_add_nameserver(dns_create_resolver_t _resolver, struct sockaddr nameserver)
	259	{
	260	_dns_resolver_buf_t resolver = (_dns_resolver_buf_t )*_resolver;
	261
	262	resolver->resolver.n_nameserver = htonl(ntohl(resolver->resolver.n_nameserver) + 1);
	263	_dns_resolver_add_attribute(_resolver, RESOLVER_ATTRIBUTE_ADDRESS, nameserver->sa_len, (void *)nameserver);
	264	return;
	265	}
	266
	267
dbf6a266	268	void
edebe297	269	_dns_resolver_set_port(dns_create_resolver_t *_resolver, uint16_t port)
dbf6a266 A	270	{
	271	_dns_resolver_buf_t resolver = (_dns_resolver_buf_t )*_resolver;
	272
	273	resolver->resolver.port = htons(port);
	274	return;
	275	}
	276
	277
dbf6a266 A	278	void
	279	_dns_resolver_add_search(dns_create_resolver_t _resolver, const char search)
	280	{
	281	_dns_resolver_buf_t resolver = (_dns_resolver_buf_t )*_resolver;
	282
	283	resolver->resolver.n_search = htonl(ntohl(resolver->resolver.n_search) + 1);
	284	_dns_resolver_add_attribute(_resolver, RESOLVER_ATTRIBUTE_SEARCH, strlen(search) + 1, (void *)search);
	285	return;
	286	}
	287
	288
dbf6a266 A	289	void
	290	_dns_resolver_add_sortaddr(dns_create_resolver_t _resolver, dns_sortaddr_t sortaddr)
	291	{
	292	_dns_resolver_buf_t resolver = (_dns_resolver_buf_t )*_resolver;
	293
	294	resolver->resolver.n_sortaddr = htonl(ntohl(resolver->resolver.n_sortaddr) + 1);
	295	_dns_resolver_add_attribute(_resolver, RESOLVER_ATTRIBUTE_SORTADDR, sizeof(dns_sortaddr_t), (void *)sortaddr);
	296	return;
	297	}
	298
	299
dbf6a266 A	300	void
	301	_dns_resolver_set_options(dns_create_resolver_t _resolver, const char options)
	302	{
	303	_dns_resolver_add_attribute(_resolver, RESOLVER_ATTRIBUTE_OPTIONS, strlen(options) + 1, (void *)options);
	304	return;
	305	}
	306
	307
dbf6a266 A	308	void
	309	_dns_resolver_set_timeout(dns_create_resolver_t *_resolver, uint32_t timeout)
	310	{
	311	_dns_resolver_buf_t resolver = (_dns_resolver_buf_t )*_resolver;
	312
	313	resolver->resolver.timeout = htonl(timeout);
	314	return;
	315	}
	316
	317
dbf6a266 A	318	void
	319	_dns_resolver_set_order(dns_create_resolver_t *_resolver, uint32_t order)
	320	{
	321	_dns_resolver_buf_t resolver = (_dns_resolver_buf_t )*_resolver;
	322
	323	resolver->resolver.search_order = htonl(order);
	324	return;
	325	}
	326
	327
dbf6a266 A	328	void
	329	_dns_resolver_free(dns_create_resolver_t *_resolver)
	330	{
	331	_dns_resolver_buf_t resolver = (_dns_resolver_buf_t )*_resolver;
	332
	333	free(resolver);
	334	*_resolver = NULL;
	335	return;
	336	}