libaddns/dns.h

ソースコードを見る。

データ構造
struct	dns_domain_label
struct	dns_domain_name
struct	dns_question
struct	dns_zone
struct	dns_rrec
struct	dns_tkey_record
struct	dns_request
struct	dns_update_request
struct	dns_connection
struct	dns_buffer
型定義
typedef long	HANDLE
typedef int	BOOL
列挙型
enum	dns_ServerType { DNS_SRV_ANY, DNS_SRV_WIN2000, DNS_SRV_WIN2003 }
関数
void *	_talloc_zero_zeronull (const void *ctx, size_t size, const char *name)
void *	_talloc_memdup_zeronull (const void *t, const void *p, size_t size, const char *name)
void *	_talloc_array_zeronull (const void *ctx, size_t el_size, unsigned count, const char *name)
void *	_talloc_zero_array_zeronull (const void *ctx, size_t el_size, unsigned count, const char *name)
void *	talloc_zeronull (const void *context, size_t size, const char *name)
DNS_ERROR	dns_domain_name_from_string (TALLOC_CTX *mem_ctx, const char *pszDomainName, struct dns_domain_name **presult)
char *	dns_generate_keyname (TALLOC_CTX *mem_ctx)
DNS_ERROR	dns_create_query (TALLOC_CTX *mem_ctx, const char *name, uint16 q_type, uint16 q_class, struct dns_request **preq)
DNS_ERROR	dns_create_update (TALLOC_CTX *mem_ctx, const char *name, struct dns_update_request **preq)
DNS_ERROR	dns_create_probe (TALLOC_CTX *mem_ctx, const char *zone, const char *host, int num_ips, const struct in_addr *iplist, struct dns_update_request **preq)
DNS_ERROR	dns_create_rrec (TALLOC_CTX *mem_ctx, const char *name, uint16 type, uint16 r_class, uint32 ttl, uint16 data_length, uint8 *data, struct dns_rrec **prec)
DNS_ERROR	dns_add_rrec (TALLOC_CTX *mem_ctx, struct dns_rrec *rec, uint16 *num_records, struct dns_rrec ***records)
DNS_ERROR	dns_create_tkey_record (TALLOC_CTX *mem_ctx, const char *keyname, const char *algorithm_name, time_t inception, time_t expiration, uint16 mode, uint16 error, uint16 key_length, const uint8 *key, struct dns_rrec **prec)
DNS_ERROR	dns_create_name_in_use_record (TALLOC_CTX *mem_ctx, const char *name, const struct in_addr *ip, struct dns_rrec **prec)
DNS_ERROR	dns_create_delete_record (TALLOC_CTX *mem_ctx, const char *name, uint16 type, uint16 r_class, struct dns_rrec **prec)
DNS_ERROR	dns_create_name_not_in_use_record (TALLOC_CTX *mem_ctx, const char *name, uint32 type, struct dns_rrec **prec)
DNS_ERROR	dns_create_a_record (TALLOC_CTX *mem_ctx, const char *host, uint32 ttl, struct in_addr ip, struct dns_rrec **prec)
DNS_ERROR	dns_unmarshall_tkey_record (TALLOC_CTX *mem_ctx, struct dns_rrec *rec, struct dns_tkey_record **ptkey)
DNS_ERROR	dns_create_tsig_record (TALLOC_CTX *mem_ctx, const char *keyname, const char *algorithm_name, time_t time_signed, uint16 fudge, uint16 mac_length, const uint8 *mac, uint16 original_id, uint16 error, struct dns_rrec **prec)
DNS_ERROR	dns_open_connection (const char *nameserver, int32 dwType, TALLOC_CTX *mem_ctx, struct dns_connection **conn)
DNS_ERROR	dns_send (struct dns_connection *conn, const struct dns_buffer *buf)
DNS_ERROR	dns_receive (TALLOC_CTX *mem_ctx, struct dns_connection *conn, struct dns_buffer **presult)
DNS_ERROR	dns_transaction (TALLOC_CTX *mem_ctx, struct dns_connection *conn, const struct dns_request *req, struct dns_request **resp)
DNS_ERROR	dns_update_transaction (TALLOC_CTX *mem_ctx, struct dns_connection *conn, struct dns_update_request *up_req, struct dns_update_request **up_resp)
dns_buffer *	dns_create_buffer (TALLOC_CTX *mem_ctx)
void	dns_marshall_buffer (struct dns_buffer *buf, const uint8 *data, size_t len)
void	dns_marshall_uint16 (struct dns_buffer *buf, uint16 val)
void	dns_marshall_uint32 (struct dns_buffer *buf, uint32 val)
void	dns_unmarshall_buffer (struct dns_buffer *buf, uint8 *data, size_t len)
void	dns_unmarshall_uint16 (struct dns_buffer *buf, uint16 *val)
void	dns_unmarshall_uint32 (struct dns_buffer *buf, uint32 *val)
void	dns_unmarshall_domain_name (TALLOC_CTX *mem_ctx, struct dns_buffer *buf, struct dns_domain_name **pname)
void	dns_marshall_domain_name (struct dns_buffer *buf, const struct dns_domain_name *name)
DNS_ERROR	dns_marshall_request (TALLOC_CTX *mem_ctx, const struct dns_request *req, struct dns_buffer **pbuf)
DNS_ERROR	dns_unmarshall_request (TALLOC_CTX *mem_ctx, struct dns_buffer *buf, struct dns_request **preq)
DNS_ERROR	dns_marshall_update_request (TALLOC_CTX *mem_ctx, struct dns_update_request *update, struct dns_buffer **pbuf)
DNS_ERROR	dns_unmarshall_update_request (TALLOC_CTX *mem_ctx, struct dns_buffer *buf, struct dns_update_request **pupreq)
dns_request *	dns_update2request (struct dns_update_request *update)
dns_update_request *	dns_request2update (struct dns_request *request)
uint16	dns_response_code (uint16 flags)
void	display_status (const char *msg, OM_uint32 maj_stat, OM_uint32 min_stat)
DNS_ERROR	dns_negotiate_sec_ctx (const char *target_realm, const char *servername, const char *keyname, gss_ctx_id_t *gss_ctx, enum dns_ServerType srv_type)
DNS_ERROR	dns_sign_update (struct dns_update_request *req, gss_ctx_id_t gss_ctx, const char *keyname, const char *algorithmname, time_t time_signed, uint16 fudge)
DNS_ERROR	dns_create_update_request (TALLOC_CTX *mem_ctx, const char *domainname, const char *hostname, const struct in_addr *ip_addr, size_t num_adds, struct dns_update_request **preq)

---

型定義

typedef long HANDLE

dns.h の 284 行で定義されています。

typedef int BOOL

dns.h の 287 行で定義されています。

---

列挙型

enum dns_ServerType

列挙型の値:

DNS_SRV_ANY
DNS_SRV_WIN2000
DNS_SRV_WIN2003

dns.h の 292 行で定義されています。

{ DNS_SRV_ANY, DNS_SRV_WIN2000, DNS_SRV_WIN2003 };

---

関数

void* _talloc_zero_zeronull	(	const void *	ctx,
		size_t	size,
		const char *	name
	)

util.c の 3250 行で定義されています。

参照先 talloc_named_const().

{
        void *p;

        if (size == 0) {
                return NULL;
        }

        p = talloc_named_const(ctx, size, name);

        if (p) {
                memset(p, '\0', size);
        }

        return p;
}

void* _talloc_memdup_zeronull	(	const void *	t,
		const void *	p,
		size_t	size,
		const char *	name
	)

util.c の 3272 行で定義されています。

参照先 talloc_named_const().

{
        void *newp;

        if (size == 0) {
                return NULL;
        }

        newp = talloc_named_const(t, size, name);
        if (newp) {
                memcpy(newp, p, size);
        }

        return newp;
}

void* _talloc_array_zeronull	(	const void *	ctx,
		size_t	el_size,
		unsigned	count,
		const char *	name
	)

util.c の 3293 行で定義されています。

参照先 talloc_named_const().

{
        if (count >= MAX_TALLOC_SIZE/el_size) {
                return NULL;
        }

        if (el_size == 0 || count == 0) {
                return NULL;
        }

        return talloc_named_const(ctx, el_size * count, name);
}

void* _talloc_zero_array_zeronull	(	const void *	ctx,
		size_t	el_size,
		unsigned	count,
		const char *	name
	)

util.c の 3311 行で定義されています。

参照先 _talloc_zero().

{
        if (count >= MAX_TALLOC_SIZE/el_size) {
                return NULL;
        }

        if (el_size == 0 || count == 0) {
                return NULL;
        }

        return _talloc_zero(ctx, el_size * count, name);
}

void* talloc_zeronull	(	const void *	context,
		size_t	size,
		const char *	name
	)

util.c の 3327 行で定義されています。

参照先 talloc_named_const().

{
        if (size == 0) {
                return NULL;
        }
        return talloc_named_const(context, size, name);
}

DNS_ERROR dns_domain_name_from_string	(	TALLOC_CTX *	mem_ctx,
		const char *	pszDomainName,
		struct dns_domain_name **	presult
	)

dnsutils.c の 109 行で定義されています。

参照先 err・LabelList()・result.

参照元 dns_create_query()・dns_create_rrec()・dns_create_tkey_record()・dns_create_tsig_record()・dns_create_update()・dns_sign_update().

{
        struct dns_domain_name *result;
        DNS_ERROR err;

        if (!(result = talloc(mem_ctx, struct dns_domain_name))) {
                return ERROR_DNS_NO_MEMORY;
        }

        err = LabelList( result, pszDomainName, &result->pLabelList );
        if (!ERR_DNS_IS_OK(err)) {
                TALLOC_FREE(result);
                return err;
        }

        *presult = result;
        return ERROR_DNS_SUCCESS;
}

char* dns_generate_keyname

(

TALLOC_CTX *

mem_ctx

)

dnsutils.c の 133 行で定義されています。

参照先 result.

参照元 DoDNSUpdate().

{
        char *result = NULL;
#if defined(WITH_DNS_UPDATES)

        uuid_t uuid;

        /*
         * uuid_unparse gives 36 bytes plus '\0'
         */
        if (!(result = TALLOC_ARRAY(mem_ctx, char, 37))) {
                return NULL;
        }

        uuid_generate( uuid );
        uuid_unparse( uuid, result );

#endif

        return result;
}

DNS_ERROR dns_create_query	(	TALLOC_CTX *	mem_ctx,
		const char *	name,
		uint16	q_type,
		uint16	q_class,
		struct dns_request **	preq
	)

dnsrecord.c の 28 行で定義されています。

参照先 dns_domain_name_from_string()・err・dns_request::id・dns_question::name・dns_request::num_questions・dns_question::q_class・dns_question::q_type・dns_request::questions.

参照元 dns_negotiate_gss_ctx_int()・do_gethostbyname().

{
        struct dns_request *req;
        struct dns_question *q;
        DNS_ERROR err;

        if (!(req = TALLOC_ZERO_P(mem_ctx, struct dns_request)) ||
            !(req->questions = TALLOC_ARRAY(req, struct dns_question *, 1)) ||
            !(req->questions[0] = talloc(req->questions,
                                         struct dns_question))) {
                TALLOC_FREE(req);
                return ERROR_DNS_NO_MEMORY;
        }

        req->id = random();

        req->num_questions = 1;
        q = req->questions[0];

        err = dns_domain_name_from_string(q, name, &q->name);
        if (!ERR_DNS_IS_OK(err)) {
                TALLOC_FREE(req);
                return err;
        }

        q->q_type = q_type;
        q->q_class = q_class;

        *preq = req;
        return ERROR_DNS_SUCCESS;
}

DNS_ERROR dns_create_update	(	TALLOC_CTX *	mem_ctx,
		const char *	name,
		struct dns_update_request **	preq
	)

dnsrecord.c の 62 行で定義されています。

参照先 dns_domain_name_from_string()・err・dns_update_request::flags・dns_update_request::id・dns_zone::name・dns_update_request::num_zones・dns_zone::z_class・dns_zone::z_type・dns_update_request::zones.

参照元 dns_create_probe()・dns_create_update_request().

{
        struct dns_update_request *req;
        struct dns_zone *z;
        DNS_ERROR err;

        if (!(req = TALLOC_ZERO_P(mem_ctx, struct dns_update_request)) ||
            !(req->zones = TALLOC_ARRAY(req, struct dns_zone *, 1)) ||
            !(req->zones[0] = talloc(req->zones, struct dns_zone))) {
                TALLOC_FREE(req);
                return ERROR_DNS_NO_MEMORY;
        }

        req->id = random();
        req->flags = 0x2800;    /* Dynamic update */

        req->num_zones = 1;
        z = req->zones[0];

        err = dns_domain_name_from_string(z, name, &z->name);
        if (!ERR_DNS_IS_OK(err)) {
                TALLOC_FREE(req);
                return err;
        }

        z->z_type = QTYPE_SOA;
        z->z_class = DNS_CLASS_IN;

        *preq = req;
        return ERROR_DNS_SUCCESS;
}

DNS_ERROR dns_create_probe	(	TALLOC_CTX *	mem_ctx,
		const char *	zone,
		const char *	host,
		int	num_ips,
		const struct in_addr *	iplist,
		struct dns_update_request **	preq
	)

dnsrecord.c の 324 行で定義されています。

参照先 dns_add_rrec()・dns_create_name_in_use_record()・dns_create_name_not_in_use_record()・dns_create_update()・err・error・dns_update_request::num_preqs・dns_update_request::preqs.

参照元 DoDNSUpdate().

{
        struct dns_update_request *req;
        struct dns_rrec *rec;
        DNS_ERROR err;
        uint16 i;

        err = dns_create_update(mem_ctx, zone, &req);
        if (!ERR_DNS_IS_OK(err)) goto error;

        err = dns_create_name_not_in_use_record(req, host, QTYPE_CNAME, &rec);
        if (!ERR_DNS_IS_OK(err)) goto error;

        err = dns_add_rrec(req, rec, &req->num_preqs, &req->preqs);
        if (!ERR_DNS_IS_OK(err)) goto error;

        for (i=0; i<num_ips; i++) {
                err = dns_create_name_in_use_record(req, host,
                                                    &iplist[i], &rec);
                if (!ERR_DNS_IS_OK(err)) goto error;

                err = dns_add_rrec(req, rec, &req->num_preqs, &req->preqs);
                if (!ERR_DNS_IS_OK(err)) goto error;
        }

        *preq = req;
        return ERROR_DNS_SUCCESS;

 error:
        TALLOC_FREE(req);
        return err;
}

DNS_ERROR dns_create_rrec	(	TALLOC_CTX *	mem_ctx,
		const char *	name,
		uint16	type,
		uint16	r_class,
		uint32	ttl,
		uint16	data_length,
		uint8 *	data,
		struct dns_rrec **	prec
	)

dnsrecord.c の 95 行で定義されています。

参照先 dns_rrec::data・dns_rrec::data_length・dns_domain_name_from_string()・err・dns_rrec::name・dns_rrec::r_class・dns_rrec::ttl・dns_rrec::type.

参照元 dns_create_a_record()・dns_create_delete_record()・dns_create_name_in_use_record()・dns_create_name_not_in_use_record()・dns_create_tkey_record()・dns_create_tsig_record()・dns_create_update_request().

{
        struct dns_rrec *rec;
        DNS_ERROR err;

        if (!(rec = talloc(mem_ctx, struct dns_rrec))) {
                return ERROR_DNS_NO_MEMORY;
        }

        err = dns_domain_name_from_string(rec, name, &rec->name);
        if (!(ERR_DNS_IS_OK(err))) {
                TALLOC_FREE(rec);
                return err;
        }

        rec->type = type;
        rec->r_class = r_class;
        rec->ttl = ttl;
        rec->data_length = data_length;
        rec->data = talloc_move(rec, &data);

        *prec = rec;
        return ERROR_DNS_SUCCESS;
}

DNS_ERROR dns_add_rrec	(	TALLOC_CTX *	mem_ctx,
		struct dns_rrec *	rec,
		uint16 *	num_records,
		struct dns_rrec ***	records
	)

dnsrecord.c の 301 行で定義されています。

参照元 dns_create_probe()・dns_create_update_request()・dns_negotiate_gss_ctx_int()・dns_sign_update().

{
        struct dns_rrec **new_records;

        if (!(new_records = TALLOC_REALLOC_ARRAY(mem_ctx, *records,
                                                 struct dns_rrec *,
                                                 (*num_records)+1))) {
                return ERROR_DNS_NO_MEMORY;
        }

        new_records[*num_records] = talloc_move(new_records, &rec);

        *num_records += 1;
        *records = new_records;
        return ERROR_DNS_SUCCESS;
}

DNS_ERROR dns_create_tkey_record	(	TALLOC_CTX *	mem_ctx,
		const char *	keyname,
		const char *	algorithm_name,
		time_t	inception,
		time_t	expiration,
		uint16	mode,
		uint16	error,
		uint16	key_length,
		const uint8 *	key,
		struct dns_rrec **	prec
	)

dnsrecord.c の 173 行で定義されています。

参照先 buf・dns_create_buffer()・dns_create_rrec()・dns_domain_name_from_string()・dns_marshall_buffer()・dns_marshall_domain_name()・dns_marshall_uint16()・dns_marshall_uint32()・err.

参照元 dns_negotiate_gss_ctx_int().

{
        struct dns_buffer *buf;
        struct dns_domain_name *algorithm;
        DNS_ERROR err;

        if (!(buf = dns_create_buffer(mem_ctx))) {
                return ERROR_DNS_NO_MEMORY;
        }

        err = dns_domain_name_from_string(buf, algorithm_name, &algorithm);
        if (!ERR_DNS_IS_OK(err)) goto error;

        dns_marshall_domain_name(buf, algorithm);
        dns_marshall_uint32(buf, inception);
        dns_marshall_uint32(buf, expiration);
        dns_marshall_uint16(buf, mode);
        dns_marshall_uint16(buf, error);
        dns_marshall_uint16(buf, key_length);
        dns_marshall_buffer(buf, key, key_length);
        dns_marshall_uint16(buf, 0); /* Other Size */

        if (!ERR_DNS_IS_OK(buf->error)) {
                err = buf->error;
                goto error;
        }

        err = dns_create_rrec(mem_ctx, keyname, QTYPE_TKEY, DNS_CLASS_ANY, 0,
                              buf->offset, buf->data, prec);

 error:
        TALLOC_FREE(buf);
        return err;
}

DNS_ERROR dns_create_name_in_use_record	(	TALLOC_CTX *	mem_ctx,
		const char *	name,
		const struct in_addr *	ip,
		struct dns_rrec **	prec
	)

dnsrecord.c の 145 行で定義されています。

参照先 dns_create_a_record()・dns_create_rrec().

参照元 dns_create_probe().

{
        if (ip != NULL) {
                return dns_create_a_record(mem_ctx, name, 0, *ip, prec);
        }

        return dns_create_rrec(mem_ctx, name, QTYPE_ANY, DNS_CLASS_IN, 0, 0,
                               NULL, prec);
}

DNS_ERROR dns_create_delete_record	(	TALLOC_CTX *	mem_ctx,
		const char *	name,
		uint16	type,
		uint16	r_class,
		struct dns_rrec **	prec
	)

dnsrecord.c の 166 行で定義されています。

参照先 dns_create_rrec().

参照元 dns_create_update_request().

{
        return dns_create_rrec(mem_ctx, name, type, r_class, 0, 0, NULL, prec);
}

DNS_ERROR dns_create_name_not_in_use_record	(	TALLOC_CTX *	mem_ctx,
		const char *	name,
		uint32	type,
		struct dns_rrec **	prec
	)

dnsrecord.c の 158 行で定義されています。

参照先 dns_create_rrec().

参照元 dns_create_probe().

{
        return dns_create_rrec(mem_ctx, name, type, DNS_CLASS_NONE, 0,
                               0, NULL, prec);
}

DNS_ERROR dns_create_a_record	(	TALLOC_CTX *	mem_ctx,
		const char *	host,
		uint32	ttl,
		struct in_addr	ip,
		struct dns_rrec **	prec
	)

dnsrecord.c の 123 行で定義されています。

参照先 dns_rrec::data・dns_create_rrec()・err.

参照元 dns_create_name_in_use_record()・dns_create_update_request().

{
        uint8 *data;
        DNS_ERROR err;

        if (!(data = (uint8 *)TALLOC_MEMDUP(mem_ctx, (const void *)&ip.s_addr,
                                            sizeof(ip.s_addr)))) {
                return ERROR_DNS_NO_MEMORY;
        }

        err = dns_create_rrec(mem_ctx, host, QTYPE_A, DNS_CLASS_IN, ttl,
                              sizeof(ip.s_addr), data, prec);

        if (!ERR_DNS_IS_OK(err)) {
                TALLOC_FREE(data);
        }

        return err;
}

DNS_ERROR dns_unmarshall_tkey_record	(	TALLOC_CTX *	mem_ctx,
		struct dns_rrec *	rec,
		struct dns_tkey_record **	ptkey
	)

dnsrecord.c の 212 行で定義されています。

参照先 dns_tkey_record::algorithm・buf・dns_rrec::data・dns_rrec::data_length・dns_unmarshall_buffer()・dns_unmarshall_domain_name()・dns_unmarshall_uint16()・dns_unmarshall_uint32()・dns_tkey_record::error・error・dns_tkey_record::expiration・dns_tkey_record::inception・dns_tkey_record::key・dns_tkey_record::key_length・dns_tkey_record::mode.

参照元 dns_negotiate_gss_ctx_int().

{
        struct dns_tkey_record *tkey;
        struct dns_buffer buf;
        uint32 tmp_inception, tmp_expiration;
        
        if (!(tkey = talloc(mem_ctx, struct dns_tkey_record))) {
                return ERROR_DNS_NO_MEMORY;
        }

        buf.data = rec->data;
        buf.size = rec->data_length;
        buf.offset = 0;
        buf.error = ERROR_DNS_SUCCESS;

        dns_unmarshall_domain_name(tkey, &buf, &tkey->algorithm);
        dns_unmarshall_uint32(&buf, &tmp_inception);
        dns_unmarshall_uint32(&buf, &tmp_expiration);
        dns_unmarshall_uint16(&buf, &tkey->mode);
        dns_unmarshall_uint16(&buf, &tkey->error);
        dns_unmarshall_uint16(&buf, &tkey->key_length);

        if (!ERR_DNS_IS_OK(buf.error)) goto error;

        if (tkey->key_length) {
                if (!(tkey->key = TALLOC_ARRAY(tkey, uint8, tkey->key_length))) {
                        buf.error = ERROR_DNS_NO_MEMORY;
                        goto error;
                }
        } else {
                tkey->key = NULL;
        }

        dns_unmarshall_buffer(&buf, tkey->key, tkey->key_length);
        if (!ERR_DNS_IS_OK(buf.error)) goto error;

        tkey->inception = (time_t)tmp_inception;
        tkey->expiration = (time_t)tmp_expiration;

        *ptkey = tkey;
        return ERROR_DNS_SUCCESS;

 error:
        TALLOC_FREE(tkey);
        return buf.error;
}

DNS_ERROR dns_create_tsig_record	(	TALLOC_CTX *	mem_ctx,
		const char *	keyname,
		const char *	algorithm_name,
		time_t	time_signed,
		uint16	fudge,
		uint16	mac_length,
		const uint8 *	mac,
		uint16	original_id,
		uint16	error,
		struct dns_rrec **	prec
	)

dnsrecord.c の 260 行で定義されています。

参照先 buf・dns_create_buffer()・dns_create_rrec()・dns_domain_name_from_string()・dns_marshall_buffer()・dns_marshall_domain_name()・dns_marshall_uint16()・dns_marshall_uint32()・err.

参照元 dns_sign_update().

{
        struct dns_buffer *buf;
        struct dns_domain_name *algorithm;
        DNS_ERROR err;

        if (!(buf = dns_create_buffer(mem_ctx))) {
                return ERROR_DNS_NO_MEMORY;
        }

        err = dns_domain_name_from_string(buf, algorithm_name, &algorithm);
        if (!ERR_DNS_IS_OK(err)) goto error;

        dns_marshall_domain_name(buf, algorithm);
        dns_marshall_uint16(buf, 0); /* time prefix */
        dns_marshall_uint32(buf, time_signed);
        dns_marshall_uint16(buf, fudge);
        dns_marshall_uint16(buf, mac_length);
        dns_marshall_buffer(buf, mac, mac_length);
        dns_marshall_uint16(buf, original_id);
        dns_marshall_uint16(buf, error);
        dns_marshall_uint16(buf, 0); /* Other Size */

        if (!ERR_DNS_IS_OK(buf->error)) {
                err = buf->error;
                goto error;
        }

        err = dns_create_rrec(mem_ctx, keyname, QTYPE_TSIG, DNS_CLASS_ANY, 0,
                              buf->offset, buf->data, prec);

 error:
        TALLOC_FREE(buf);
        return err;
}

DNS_ERROR dns_open_connection	(	const char *	nameserver,
		int32	dwType,
		TALLOC_CTX *	mem_ctx,
		struct dns_connection **	conn
	)

dnssock.c の 137 行で定義されています。

参照先 dns_tcp_open()・dns_udp_open().

参照元 dns_negotiate_sec_ctx()・do_gethostbyname()・DoDNSUpdate().

{
        switch ( dwType ) {
        case DNS_TCP:
                return dns_tcp_open( nameserver, mem_ctx, conn );
        case DNS_UDP:
                return dns_udp_open( nameserver, mem_ctx, conn );
        }
        
        return ERROR_DNS_INVALID_PARAMETER;
}

DNS_ERROR dns_send	(	struct dns_connection *	conn,
		const struct dns_buffer *	buf
	)

dnssock.c の 200 行で定義されています。

参照先 buf・dns_send_tcp()・dns_send_udp()・dns_connection::hType.

参照元 dns_negotiate_gss_ctx_int()・dns_transaction().

{
        if (conn->hType == DNS_TCP) {
                return dns_send_tcp(conn, buf);
        }

        if (conn->hType == DNS_UDP) {
                return dns_send_udp(conn, buf);
        }

        return ERROR_DNS_INVALID_PARAMETER;
}

DNS_ERROR dns_receive	(	TALLOC_CTX *	mem_ctx,
		struct dns_connection *	conn,
		struct dns_buffer **	presult
	)

dnssock.c の 325 行で定義されています。

参照先 dns_receive_tcp()・dns_receive_udp()・dns_connection::hType.

参照元 dns_negotiate_gss_ctx_int()・dns_transaction().

{
        if (conn->hType == DNS_TCP) {
                return dns_receive_tcp(mem_ctx, conn, presult);
        }

        if (conn->hType == DNS_UDP) {
                return dns_receive_udp(mem_ctx, conn, presult);
        }

        return ERROR_DNS_INVALID_PARAMETER;
}

DNS_ERROR dns_transaction	(	TALLOC_CTX *	mem_ctx,
		struct dns_connection *	conn,
		const struct dns_request *	req,
		struct dns_request **	resp
	)

dnssock.c の 339 行で定義されています。

参照先 buf・dns_marshall_request()・dns_receive()・dns_send()・dns_unmarshall_request()・err・error.

参照元 dns_update_transaction()・do_gethostbyname().

{
        struct dns_buffer *buf = NULL;
        DNS_ERROR err;

        err = dns_marshall_request(conn, req, &buf);
        if (!ERR_DNS_IS_OK(err)) goto error;

        err = dns_send(conn, buf);
        if (!ERR_DNS_IS_OK(err)) goto error;
        TALLOC_FREE(buf);

        err = dns_receive(mem_ctx, conn, &buf);
        if (!ERR_DNS_IS_OK(err)) goto error;

        err = dns_unmarshall_request(mem_ctx, buf, resp);

 error:
        TALLOC_FREE(buf);
        return err;
}

DNS_ERROR dns_update_transaction	(	TALLOC_CTX *	mem_ctx,
		struct dns_connection *	conn,
		struct dns_update_request *	up_req,
		struct dns_update_request **	up_resp
	)

dnssock.c の 363 行で定義されています。

参照先 dns_request2update()・dns_transaction()・dns_update2request()・err.

参照元 DoDNSUpdate().

{
        struct dns_request *resp;
        DNS_ERROR err;

        err = dns_transaction(mem_ctx, conn, dns_update2request(up_req),
                              &resp);

        if (!ERR_DNS_IS_OK(err)) return err;

        *up_resp = dns_request2update(resp);
        return ERROR_DNS_SUCCESS;
}

struct dns_buffer* dns_create_buffer

(

TALLOC_CTX *

mem_ctx

)

dnsmarshall.c の 28 行で定義されています。

参照先 result.

参照元 dns_create_tkey_record()・dns_create_tsig_record()・dns_marshall_request().

{
        struct dns_buffer *result;

        if (!(result = talloc(mem_ctx, struct dns_buffer))) {
                return NULL;
        }

        result->offset = 0;
        result->error = ERROR_DNS_SUCCESS;
        
        /*
         * Small inital size to excercise the realloc code
         */
        result->size = 2;

        if (!(result->data = TALLOC_ARRAY(result, uint8, result->size))) {
                TALLOC_FREE(result);
                return NULL;
        }

        return result;
}

void dns_marshall_buffer	(	struct dns_buffer *	buf,
		const uint8 *	data,
		size_t	len
	)

dnsmarshall.c の 52 行で定義されています。

参照先 buf・dns_buffer::offset.

参照元 dns_create_tkey_record()・dns_create_tsig_record()・dns_marshall_domain_name()・dns_marshall_rr()・dns_marshall_uint16()・dns_marshall_uint32().

{
        if (!ERR_DNS_IS_OK(buf->error)) return;

        if (buf->offset + len < buf->offset) {
                /*
                 * Wraparound!
                 */
                buf->error = ERROR_DNS_INVALID_PARAMETER;
                return;
        }

        if ((buf->offset + len) > 0xffff) {
                /*
                 * Only 64k possible
                 */
                buf->error = ERROR_DNS_INVALID_PARAMETER;
                return;
        }
                
        if (buf->offset + len > buf->size) {
                size_t new_size = buf->offset + len;
                uint8 *new_data;

                /*
                 * Don't do too many reallocs, round up to some multiple
                 */

                new_size += (64 - (new_size % 64));

                if (!(new_data = TALLOC_REALLOC_ARRAY(buf, buf->data, uint8,
                                                      new_size))) {
                        buf->error = ERROR_DNS_NO_MEMORY;
                        return;
                }

                buf->size = new_size;
                buf->data = new_data;
        }

        memcpy(buf->data + buf->offset, data, len);
        buf->offset += len;
        return;
}

void dns_marshall_uint16	(	struct dns_buffer *	buf,
		uint16	val
	)

dnsmarshall.c の 98 行で定義されています。

参照先 buf・dns_marshall_buffer().

参照元 dns_create_tkey_record()・dns_create_tsig_record()・dns_marshall_question()・dns_marshall_request()・dns_marshall_rr()・dns_sign_update().

{
        uint16 n_val = htons(val);
        dns_marshall_buffer(buf, (uint8 *)&n_val, sizeof(n_val));
}

void dns_marshall_uint32	(	struct dns_buffer *	buf,
		uint32	val
	)

dnsmarshall.c の 104 行で定義されています。

参照先 buf・dns_marshall_buffer().

参照元 dns_create_tkey_record()・dns_create_tsig_record()・dns_marshall_rr()・dns_sign_update().

{
        uint32 n_val = htonl(val);
        dns_marshall_buffer(buf, (uint8 *)&n_val, sizeof(n_val));
}

void dns_unmarshall_buffer	(	struct dns_buffer *	buf,
		uint8 *	data,
		size_t	len
	)

dnsmarshall.c の 110 行で定義されています。

参照先 buf.

参照元 dns_unmarshall_label()・dns_unmarshall_rr()・dns_unmarshall_tkey_record()・dns_unmarshall_uint16()・dns_unmarshall_uint32().

{
        if (!(ERR_DNS_IS_OK(buf->error))) return;

        if ((len > buf->size) || (buf->offset + len > buf->size)) {
                buf->error = ERROR_DNS_INVALID_MESSAGE;
                return;
        }

        memcpy((void *)data, (const void *)(buf->data + buf->offset), len);
        buf->offset += len;

        return;
}

void dns_unmarshall_uint16	(	struct dns_buffer *	buf,
		uint16 *	val
	)

dnsmarshall.c の 126 行で定義されています。

参照先 buf・dns_unmarshall_buffer().

参照元 dns_unmarshall_question()・dns_unmarshall_request()・dns_unmarshall_rr()・dns_unmarshall_tkey_record().

{
        uint16 n_val;

        dns_unmarshall_buffer(buf, (uint8 *)&n_val, sizeof(n_val));
        if (!(ERR_DNS_IS_OK(buf->error))) return;

        *val = ntohs(n_val);
}

void dns_unmarshall_uint32	(	struct dns_buffer *	buf,
		uint32 *	val
	)

dnsmarshall.c の 136 行で定義されています。

参照先 buf・dns_unmarshall_buffer().

参照元 dns_unmarshall_rr()・dns_unmarshall_tkey_record().

{
        uint32 n_val;

        dns_unmarshall_buffer(buf, (uint8 *)&n_val, sizeof(n_val));
        if (!(ERR_DNS_IS_OK(buf->error))) return;

        *val = ntohl(n_val);
}

void dns_unmarshall_domain_name	(	TALLOC_CTX *	mem_ctx,
		struct dns_buffer *	buf,
		struct dns_domain_name **	pname
	)

dnsmarshall.c の 247 行で定義されています。

参照先 buf・dns_unmarshall_label()・name.

参照元 dns_unmarshall_question()・dns_unmarshall_rr()・dns_unmarshall_tkey_record().

{
        struct dns_domain_name *name;

        if (!ERR_DNS_IS_OK(buf->error)) return;

        if (!(name = talloc(mem_ctx, struct dns_domain_name))) {
                buf->error = ERROR_DNS_NO_MEMORY;
        }

        dns_unmarshall_label(name, 0, buf, &name->pLabelList);

        if (!ERR_DNS_IS_OK(buf->error)) {
                return;
        }

        *pname = name;
        return;
}

void dns_marshall_domain_name	(	struct dns_buffer *	buf,
		const struct dns_domain_name *	name
	)

dnsmarshall.c の 146 行で定義されています。

参照先 buf・dns_marshall_buffer()・dns_domain_label::label・len・name.

参照元 dns_create_tkey_record()・dns_create_tsig_record()・dns_marshall_question()・dns_marshall_rr()・dns_sign_update().

{
        struct dns_domain_label *label;
        char end_char = '\0';

        /*
         * TODO: Implement DNS compression
         */

        for (label = name->pLabelList; label != NULL; label = label->next) {
                uint8 len = label->len;

                dns_marshall_buffer(buf, (uint8 *)&len, sizeof(len));
                if (!ERR_DNS_IS_OK(buf->error)) return;

                dns_marshall_buffer(buf, (uint8 *)label->label, len);
                if (!ERR_DNS_IS_OK(buf->error)) return;
        }

        dns_marshall_buffer(buf, (uint8 *)&end_char, 1);
}

DNS_ERROR dns_marshall_request	(	TALLOC_CTX *	mem_ctx,
		const struct dns_request *	req,
		struct dns_buffer **	pbuf
	)

dnsmarshall.c の 345 行で定義されています。

参照先 dns_request::additionals・dns_request::answers・dns_request::auths・buf・dns_create_buffer()・dns_marshall_question()・dns_marshall_rr()・dns_marshall_uint16()・err・dns_request::flags・dns_request::id・dns_request::num_additionals・dns_request::num_answers・dns_request::num_auths・dns_request::num_questions・dns_request::questions.

参照元 dns_marshall_update_request()・dns_negotiate_gss_ctx_int()・dns_transaction().

{
        struct dns_buffer *buf;
        uint16 i;

        if (!(buf = dns_create_buffer(mem_ctx))) {
                return ERROR_DNS_NO_MEMORY;
        }

        dns_marshall_uint16(buf, req->id);
        dns_marshall_uint16(buf, req->flags);
        dns_marshall_uint16(buf, req->num_questions);
        dns_marshall_uint16(buf, req->num_answers);
        dns_marshall_uint16(buf, req->num_auths);
        dns_marshall_uint16(buf, req->num_additionals);

        for (i=0; i<req->num_questions; i++) {
                dns_marshall_question(buf, req->questions[i]);
        }
        for (i=0; i<req->num_answers; i++) {
                dns_marshall_rr(buf, req->answers[i]);
        }
        for (i=0; i<req->num_auths; i++) {
                dns_marshall_rr(buf, req->auths[i]);
        }
        for (i=0; i<req->num_additionals; i++) {
                dns_marshall_rr(buf, req->additionals[i]);
        }

        if (!ERR_DNS_IS_OK(buf->error)) {
                DNS_ERROR err = buf->error;
                TALLOC_FREE(buf);
                return err;
        }

        *pbuf = buf;
        return ERROR_DNS_SUCCESS;
}

DNS_ERROR dns_unmarshall_request	(	TALLOC_CTX *	mem_ctx,
		struct dns_buffer *	buf,
		struct dns_request **	preq
	)

dnsmarshall.c の 386 行で定義されています。

参照先 dns_request::additionals・dns_request::answers・dns_request::auths・buf・dns_unmarshall_question()・dns_unmarshall_rr()・dns_unmarshall_uint16()・err・error・dns_request::flags・dns_request::id・dns_request::num_additionals・dns_request::num_answers・dns_request::num_auths・dns_request::num_questions・dns_request::questions.

参照元 dns_negotiate_gss_ctx_int()・dns_transaction()・dns_unmarshall_update_request().

{
        struct dns_request *req;
        uint16 i;
        DNS_ERROR err;

        if (!(req = TALLOC_ZERO_P(mem_ctx, struct dns_request))) {
                return ERROR_DNS_NO_MEMORY;
        }

        dns_unmarshall_uint16(buf, &req->id);
        dns_unmarshall_uint16(buf, &req->flags);
        dns_unmarshall_uint16(buf, &req->num_questions);
        dns_unmarshall_uint16(buf, &req->num_answers);
        dns_unmarshall_uint16(buf, &req->num_auths);
        dns_unmarshall_uint16(buf, &req->num_additionals);

        if (!ERR_DNS_IS_OK(buf->error)) goto error;

        err = ERROR_DNS_NO_MEMORY;

        if ((req->num_questions != 0) &&
            !(req->questions = TALLOC_ARRAY(req, struct dns_question *,
                                            req->num_questions))) {
                goto error;
        }
        if ((req->num_answers != 0) &&
            !(req->answers = TALLOC_ARRAY(req, struct dns_rrec *,
                                          req->num_answers))) {
                goto error;
        }
        if ((req->num_auths != 0) &&
            !(req->auths = TALLOC_ARRAY(req, struct dns_rrec *,
                                        req->num_auths))) {
                goto error;
        }
        if ((req->num_additionals != 0) &&
            !(req->additionals = TALLOC_ARRAY(req, struct dns_rrec *,
                                              req->num_additionals))) {
                goto error;
        }

        for (i=0; i<req->num_questions; i++) {
                dns_unmarshall_question(req->questions, buf,
                                        &req->questions[i]);
        }
        for (i=0; i<req->num_answers; i++) {
                dns_unmarshall_rr(req->answers, buf,
                                  &req->answers[i]);
        }
        for (i=0; i<req->num_auths; i++) {
                dns_unmarshall_rr(req->auths, buf,
                                  &req->auths[i]);
        }
        for (i=0; i<req->num_additionals; i++) {
                dns_unmarshall_rr(req->additionals, buf,
                                  &req->additionals[i]);
        }

        if (!ERR_DNS_IS_OK(buf->error)) {
                err = buf->error;
                goto error;
        }

        *preq = req;
        return ERROR_DNS_SUCCESS;

 error:
        err = buf->error;
        TALLOC_FREE(req);
        return err;
}

DNS_ERROR dns_marshall_update_request	(	TALLOC_CTX *	mem_ctx,
		struct dns_update_request *	update,
		struct dns_buffer **	pbuf
	)

dnsmarshall.c の 508 行で定義されています。

参照先 dns_marshall_request()・dns_update2request().

参照元 dns_sign_update().

{
        return dns_marshall_request(mem_ctx, dns_update2request(update), pbuf);
}

DNS_ERROR dns_unmarshall_update_request	(	TALLOC_CTX *	mem_ctx,
		struct dns_buffer *	buf,
		struct dns_update_request **	pupreq
	)

dnsmarshall.c の 515 行で定義されています。

参照先 buf・dns_unmarshall_request().

{
        /*
         * See comments above about portability. If the above works, this will
         * as well.
         */

        return dns_unmarshall_request(mem_ctx, buf,
                                      (struct dns_request **)(void *)pupreq);
}

struct dns_request* dns_update2request

(

struct dns_update_request *

update

)

dnsmarshall.c の 461 行で定義されています。

参照先 dns_request::additionals・dns_update_request::additionals・dns_request::answers・dns_request::auths・dns_request::flags・dns_update_request::flags・dns_request::id・dns_update_request::id・dns_request::num_additionals・dns_update_request::num_additionals・dns_request::num_answers・dns_request::num_auths・dns_update_request::num_preqs・dns_request::num_questions・dns_update_request::num_updates・dns_update_request::num_zones・dns_update_request::preqs・dns_request::questions・dns_update_request::updates・dns_update_request::zones.

参照元 dns_marshall_update_request()・dns_update_transaction().

{
        struct dns_request *req;

        /*
         * This is a non-specified construct that happens to work on Linux/gcc
         * and I would expect it to work everywhere else. dns_request and
         * dns_update_request are essentially the same structures with
         * different names, so any difference would mean that the compiler
         * applied two different variations of padding given the same types in
         * the structures.
         */

        req = (struct dns_request *)(void *)update;

        /*
         * The assert statement here looks like we could do the equivalent
         * assignments to get portable, but it would mean that we have to
         * allocate the dns_question record for the dns_zone records. We
         * assume that if this assert works then the same holds true for
         * dns_zone<>dns_question as well.
         */

#ifdef DEVELOPER
        assert((req->id == update->id) && (req->flags == update->flags) &&
               (req->num_questions == update->num_zones) &&
               (req->num_answers == update->num_preqs) &&
               (req->num_auths == update->num_updates) &&
               (req->num_additionals == update->num_additionals) &&
               (req->questions ==
                (struct dns_question **)(void *)update->zones) &&
               (req->answers == update->preqs) &&
               (req->auths == update->updates) &&
               (req->additionals == update->additionals));
#endif

        return req;
}

struct dns_update_request* dns_request2update

(

struct dns_request *

request

)

dnsmarshall.c の 500 行で定義されています。

参照元 dns_update_transaction().

{
        /*
         * For portability concerns see dns_update2request;
         */
        return (struct dns_update_request *)(void *)request;
}

uint16 dns_response_code

(

uint16

flags

)

dnsmarshall.c の 528 行で定義されています。

参照元 DoDNSUpdate().

{
        return flags & 0xF;
}

void display_status	(	const char *	msg,
		OM_uint32	maj_stat,
		OM_uint32	min_stat
	)

dnsgss.c の 75 行で定義されています。

参照先 display_status_1().

{
        display_status_1( msg, maj_stat, GSS_C_GSS_CODE );
        display_status_1( msg, min_stat, GSS_C_MECH_CODE );
}

DNS_ERROR dns_negotiate_sec_ctx	(	const char *	target_realm,
		const char *	servername,
		const char *	keyname,
		gss_ctx_id_t *	gss_ctx,
		enum dns_ServerType	srv_type
	)

dnsgss.c の 208 行で定義されています。

参照先 dns_negotiate_gss_ctx_int()・dns_open_connection()・err・error・strupr()・talloc_asprintf()・talloc_init()・talloc_strdup().

参照元 DoDNSUpdate().

{
        OM_uint32 major, minor;

        char *upcaserealm, *targetname;
        DNS_ERROR err;

        gss_buffer_desc input_name;
        struct dns_connection *conn;

        gss_name_t targ_name;

        krb5_principal host_principal;
        krb5_context krb_ctx = NULL;

        gss_OID_desc nt_host_oid_desc =
                { 10, (char *)"\052\206\110\206\367\022\001\002\002\002" };

        TALLOC_CTX *mem_ctx;

        if (!(mem_ctx = talloc_init("dns_negotiate_sec_ctx"))) {
                return ERROR_DNS_NO_MEMORY;
        }

        err = dns_open_connection( servername, DNS_TCP, mem_ctx, &conn );
        if (!ERR_DNS_IS_OK(err)) goto error;

        if (!(upcaserealm = talloc_strdup(mem_ctx, target_realm))) {
                err = ERROR_DNS_NO_MEMORY;
                goto error;
        }

        strupr(upcaserealm);

        if (!(targetname = talloc_asprintf(mem_ctx, "dns/%s@%s",
                                           servername, upcaserealm))) {
                err = ERROR_DNS_NO_MEMORY;
                goto error;
        }

        krb5_init_context( &krb_ctx );
        krb5_parse_name( krb_ctx, targetname, &host_principal );

        /* don't free the principal until after you call
           gss_release_name() or else you'll get a segv
           as the krb5_copy_principal() does a structure 
           copy and not a deep copy.    --jerry*/

        input_name.value = &host_principal;
        input_name.length = sizeof( host_principal );

        major = gss_import_name( &minor, &input_name,
                                 &nt_host_oid_desc, &targ_name );

        if (major) {
                krb5_free_principal( krb_ctx, host_principal );
                krb5_free_context( krb_ctx );
                err = ERROR_DNS_GSS_ERROR;
                goto error;
        }

        err = dns_negotiate_gss_ctx_int(mem_ctx, conn, keyname, 
                                        targ_name, gss_ctx, srv_type );
        
        gss_release_name( &minor, &targ_name );

        /* now we can free the principal */

        krb5_free_principal( krb_ctx, host_principal );
        krb5_free_context( krb_ctx );

 error:
        TALLOC_FREE(mem_ctx);

        return err;
}

DNS_ERROR dns_sign_update	(	struct dns_update_request *	req,
		gss_ctx_id_t	gss_ctx,
		const char *	keyname,
		const char *	algorithmname,
		time_t	time_signed,
		uint16	fudge
	)

dnsgss.c の 289 行で定義されています。

参照先 dns_update_request::additionals・buf・dns_add_rrec()・dns_create_tsig_record()・dns_domain_name_from_string()・dns_marshall_domain_name()・dns_marshall_uint16()・dns_marshall_uint32()・dns_marshall_update_request()・err・error・dns_update_request::id・dns_update_request::num_additionals.

参照元 DoDNSUpdate().

{
        struct dns_buffer *buf;
        DNS_ERROR err;
        struct dns_domain_name *key, *algorithm;
        struct gss_buffer_desc_struct msg, mic;
        OM_uint32 major, minor;
        struct dns_rrec *rec;

        err = dns_marshall_update_request(req, req, &buf);
        if (!ERR_DNS_IS_OK(err)) return err;

        err = dns_domain_name_from_string(buf, keyname, &key);
        if (!ERR_DNS_IS_OK(err)) goto error;

        err = dns_domain_name_from_string(buf, algorithmname, &algorithm);
        if (!ERR_DNS_IS_OK(err)) goto error;

        dns_marshall_domain_name(buf, key);
        dns_marshall_uint16(buf, DNS_CLASS_ANY);
        dns_marshall_uint32(buf, 0); /* TTL */
        dns_marshall_domain_name(buf, algorithm);
        dns_marshall_uint16(buf, 0); /* Time prefix for 48-bit time_t */
        dns_marshall_uint32(buf, time_signed);
        dns_marshall_uint16(buf, fudge);
        dns_marshall_uint16(buf, 0); /* error */
        dns_marshall_uint16(buf, 0); /* other len */

        err = buf->error;
        if (!ERR_DNS_IS_OK(buf->error)) goto error;

        msg.value = (void *)buf->data;
        msg.length = buf->offset;

        major = gss_get_mic(&minor, gss_ctx, 0, &msg, &mic);
        if (major != 0) {
                err = ERROR_DNS_GSS_ERROR;
                goto error;
        }

        if (mic.length > 0xffff) {
                gss_release_buffer(&minor, &mic);
                err = ERROR_DNS_GSS_ERROR;
                goto error;
        }

        err = dns_create_tsig_record(buf, keyname, algorithmname, time_signed,
                                     fudge, mic.length, (uint8 *)mic.value,
                                     req->id, 0, &rec);
        gss_release_buffer(&minor, &mic);
        if (!ERR_DNS_IS_OK(err)) goto error;

        err = dns_add_rrec(req, rec, &req->num_additionals, &req->additionals);

 error:
        TALLOC_FREE(buf);
        return err;
}

DNS_ERROR dns_create_update_request	(	TALLOC_CTX *	mem_ctx,
		const char *	domainname,
		const char *	hostname,
		const struct in_addr *	ip_addr,
		size_t	num_adds,
		struct dns_update_request **	preq
	)

dnsrecord.c の 360 行で定義されています。

参照先 dns_add_rrec()・dns_create_a_record()・dns_create_delete_record()・dns_create_rrec()・dns_create_update()・err・error・dns_update_request::num_preqs・dns_update_request::num_updates・dns_update_request::preqs・dns_update_request::updates.

参照元 DoDNSUpdate().

{
        struct dns_update_request *req;
        struct dns_rrec *rec;
        DNS_ERROR err;
        size_t i;       

        err = dns_create_update(mem_ctx, domainname, &req);
        if (!ERR_DNS_IS_OK(err)) return err;

        /*
         * The zone must be used at all
         */

        err = dns_create_rrec(req, domainname, QTYPE_ANY, DNS_CLASS_ANY,
                              0, 0, NULL, &rec);
        if (!ERR_DNS_IS_OK(err)) goto error;

        err = dns_add_rrec(req, rec, &req->num_preqs, &req->preqs);
        if (!ERR_DNS_IS_OK(err)) goto error;

        /*
         * Delete any existing A records
         */

        err = dns_create_delete_record(req, hostname, QTYPE_A, DNS_CLASS_ANY,
                                       &rec);
        if (!ERR_DNS_IS_OK(err)) goto error;
        
        err = dns_add_rrec(req, rec, &req->num_updates, &req->updates);
        if (!ERR_DNS_IS_OK(err)) goto error;

        /*
         * .. and add our IPs
         */

        for ( i=0; i<num_addrs; i++ ) {         
                err = dns_create_a_record(req, hostname, 3600, ip_addrs[i], &rec);
                if (!ERR_DNS_IS_OK(err)) 
                        goto error;

                err = dns_add_rrec(req, rec, &req->num_updates, &req->updates);
                if (!ERR_DNS_IS_OK(err)) 
                        goto error;
        }       

        *preq = req;
        return ERROR_DNS_SUCCESS;

 error:
        TALLOC_FREE(req);
        return err;
}

---