diff --git a/client/dhclient.8 b/client/dhclient.8

index a29757a..c66a912 100644

--- a/client/dhclient.8

+++ b/client/dhclient.8

@@ -56,6 +56,12 @@ dhclient - Dynamic Host Configuration Protocol Client

 ]

 ]

 [

+.B -i

+]

+[

+.B -C

+]

+[

 .B -D

 .I LL|LLT

 ]

@@ -441,6 +447,17 @@ Set the giaddr field of all packets to the \fIrelay\fR IP address

 simulating a relay agent.  This is for testing pruposes only and

 should not be expected to work in any consistent or useful way.

 .TP

+.BI \-i

+Use a DUID with DHCPv4 clients.  If no DUID is available in the

+lease file one will be constructed and saved.  The DUID will be

+used to contstuct a RFC4361 style client id that will be included

+in the client's messages.  This client id can be overridden by

+setting a client id in the configuration file.  Overridding the

+client id in this fashion is discouraged.

+.TP

+.BI \-C

+Use the standard DDNS scheme from RFCs 4701 & 4702.  

+.TP

 .BI \--version

 Print version number and exit.

 .PP

@@ -470,8 +487,10 @@ DHCPv6 \fBdhclient\fR creates an identifier based on the link-layer address

 (DUID-LL) if it is running in stateless mode (with \fB\-S\fR, not

 requesting an address), or it creates an identifier based on the

 link-layer address plus a timestamp (DUID-LLT) if it is running in

-stateful mode (without \fB\-S\fR, requesting an address).  \fB\-D\fR

-overrides this default, with a value of either \fILL\fR or \fILLT\fR.

+stateful mode (without \fB\-S\fR, requesting an address).  When DHCPv4

+is configued to use a DUID using \fB\-i\fR option the default is to use

+a DUID-LLT.  \fB\-D\fR

+overrides these default, with a value of either \fILL\fR or \fILLT\fR.

 .TP

 .BI \-N

 .\" TODO: is this for telling an already running dhclient?

diff --git a/client/dhclient.c b/client/dhclient.c

index 0db4703..6403754 100644

--- a/client/dhclient.c

+++ b/client/dhclient.c

@@ -79,6 +79,8 @@ struct sockaddr_in sockaddr_broadcast;

 struct in_addr giaddr;

 struct data_string default_duid;

 int duid_type = 0;

+int duid_v4 = 0;

+int std_dhcid = 0;

 /* ASSERT_STATE() does nothing now; it used to be

    assert (state_is == state_shouldbe). */

@@ -325,12 +327,9 @@ main(int argc, char **argv) {

 				wanted_ia_na = 0;

 			}

 			wanted_ia_pd++;

+#endif /* DHCPv6 */

 		} else if (!strcmp(argv[i], "-D")) {

-			if (local_family_set && (local_family == AF_INET)) {

-				usage();

-			}

-			local_family_set = 1;

-			local_family = AF_INET6;

+			duid_v4 = 1;

 			if (++i == argc)

 				usage();

 			if (!strcasecmp(argv[i], "LL")) {

@@ -340,7 +339,12 @@ main(int argc, char **argv) {

 			} else {

 				usage();

 			}

-#endif /* DHCPv6 */

+		} else if (!strcmp(argv[i], "-i")) {

+			/* enable DUID support for DHCPv4 clients */

+			duid_v4 = 1;

+		} else if (!strcmp(argv[i], "-C")) {

+			/* enable standard DHCID support for DDNS updates */

+			std_dhcid = 1;

 		} else if (!strcmp(argv[i], "-v")) {

 			quiet = 0;

 		} else if (!strcmp(argv[i], "--version")) {

@@ -970,12 +974,13 @@ main(int argc, char **argv) {

 		}

 	}

-	/* Start a configuration state machine for each interface. */

-#ifdef DHCPv6

-	if (local_family == AF_INET6) {

-		/* Establish a default DUID.  This may be moved to the

-		 * DHCPv4 area later.

-		 */

+

+	/*

+	 * Establish a default DUID.  We always do so for v6 and

+	 * do so if desired for v4 via the -D or -i options

+	 */

+	if ((local_family == AF_INET6) ||

+	    ((local_family == AF_INET) && (duid_v4 == 1))) {

 		if (default_duid.len == 0) {

 			if (default_duid.buffer != NULL)

 				data_string_forget(&default_duid, MDL);

@@ -983,7 +988,11 @@ main(int argc, char **argv) {

 			if (form_duid(&default_duid, MDL) == ISC_R_SUCCESS)

 				write_duid(&default_duid);

 		}

+	}

+	/* Start a configuration state machine for each interface. */

+#ifdef DHCPv6

+	if (local_family == AF_INET6) {

 		for (ip = interfaces ; ip != NULL ; ip = ip->next) {

 			for (client = ip->client ; client != NULL ;

 			     client = client->next) {

@@ -1115,9 +1124,9 @@ static void usage()

 	log_fatal("Usage: dhclient "

 #ifdef DHCPv6

-		  "[-4|-6] [-SNTP1dvrx] [-nw] [-p <port>] [-D LL|LLT]\n"

+		  "[-4|-6] [-SNTPI1dvrxc] [-nw] [-p <port>] [-D LL|LLT] \n"

 #else /* DHCPv6 */

-		  "[-1dvrx] [-nw] [-p <port>]\n"

+		  "[-C1dvrxc] [-nw] [-p <port>] [-D LL|LLT] \n"

 #endif /* DHCPv6 */

 		  "                [-s server-addr] [-cf config-file] "

 		  "[-lf lease-file]\n"

@@ -2823,24 +2832,24 @@ make_client_options(struct client_state *client, struct client_lease *lease,

 	unsigned i;

 	struct option_cache *oc;

 	struct option *option = NULL;

-	struct buffer *bp = (struct buffer *)0;

+	struct buffer *bp = NULL;

 	/* If there are any leftover options, get rid of them. */

 	if (*op)

-		option_state_dereference (op, MDL);

+		option_state_dereference(op, MDL);

 	/* Allocate space for options. */

-	option_state_allocate (op, MDL);

+	option_state_allocate(op, MDL);

 	/* Send the server identifier if provided. */

 	if (sid)

-		save_option (&dhcp_universe, *op, sid);

+		save_option(&dhcp_universe, *op, sid);

-	oc = (struct option_cache *)0;

+	oc = NULL;

 	/* Send the requested address if provided. */

 	if (rip) {

-		client -> requested_address = *rip;

+		client->requested_address = *rip;

 		i = DHO_DHCP_REQUESTED_ADDRESS;

 		if (!(option_code_hash_lookup(&option, dhcp_universe.code_hash,

 					      &i, 0, MDL) &&

@@ -2848,22 +2857,22 @@ make_client_options(struct client_state *client, struct client_lease *lease,

 					      option, MDL)))

 			log_error ("can't make requested address cache.");

 		else {

-			save_option (&dhcp_universe, *op, oc);

-			option_cache_dereference (&oc, MDL);

+			save_option(&dhcp_universe, *op, oc);

+			option_cache_dereference(&oc, MDL);

 		}

 		option_dereference(&option, MDL);

 	} else {

-		client -> requested_address.len = 0;

+		client->requested_address.len = 0;

 	}

 	i = DHO_DHCP_MESSAGE_TYPE;

 	if (!(option_code_hash_lookup(&option, dhcp_universe.code_hash, &i, 0,

 				      MDL) &&

 	      make_const_option_cache(&oc, NULL, type, 1, option, MDL)))

-		log_error ("can't make message type.");

+		log_error("can't make message type.");

 	else {

-		save_option (&dhcp_universe, *op, oc);

-		option_cache_dereference (&oc, MDL);

+		save_option(&dhcp_universe, *op, oc);

+		option_cache_dereference(&oc, MDL);

 	}

 	option_dereference(&option, MDL);

@@ -2876,8 +2885,8 @@ make_client_options(struct client_state *client, struct client_lease *lease,

 			if (prl[i]->universe == &dhcp_universe)

 				len++;

-		if (!buffer_allocate (&bp, len, MDL))

-			log_error ("can't make parameter list buffer.");

+		if (!buffer_allocate(&bp, len, MDL))

+			log_error("can't make parameter list buffer.");

 		else {

 			unsigned code = DHO_DHCP_PARAMETER_REQUEST_LIST;

@@ -2891,15 +2900,69 @@ make_client_options(struct client_state *client, struct client_lease *lease,

 						      &code, 0, MDL) &&

 			      make_const_option_cache(&oc, &bp, NULL, len,

 						      option, MDL)))

-				log_error ("can't make option cache");

+				log_error("can't make option cache");

 			else {

-				save_option (&dhcp_universe, *op, oc);

-				option_cache_dereference (&oc, MDL);

+				save_option(&dhcp_universe, *op, oc);

+				option_cache_dereference(&oc, MDL);

 			}

 			option_dereference(&option, MDL);

 		}

 	}

+	/*

+	 * If requested (duid_v4 == 1) add an RFC4361 compliant client-identifier

+	 * This can be overridden by including a client id in the configuration

+	 * file.

+	 */

+ 	if (duid_v4 == 1) {

+		struct data_string client_identifier;

+		int hw_idx, hw_len;

+

+		memset(&client_identifier, 0, sizeof(client_identifier));

+		client_identifier.len = 1 + 4 + default_duid.len;

+		if (!buffer_allocate(&client_identifier.buffer,

+				     client_identifier.len, MDL))

+			log_fatal("no memory for default DUID!");

+		client_identifier.data = client_identifier.buffer->data;

+

+		i = DHO_DHCP_CLIENT_IDENTIFIER;

+

+		/* Client-identifier type : 1 byte */

+		*client_identifier.buffer->data = 255;

+		

+		/* IAID : 4 bytes

+		 * we use the low 4 bytes from the interface address

+		 */

+		if (client->interface->hw_address.hlen > 4) {

+			hw_idx = client->interface->hw_address.hlen - 4;

+			hw_len = 4;

+		} else {

+			hw_idx = 0;

+			hw_len = client->interface->hw_address.hlen;

+		}

+		memcpy(&client_identifier.buffer->data + 5 - hw_len,

+		       client->interface->hw_address.hbuf + hw_idx,

+		       hw_len);

+	

+		/* Add the default duid */

+		memcpy(&client_identifier.buffer->data+(1+4),

+		       default_duid.data, default_duid.len);

+

+		/* And save the option */

+		if (!(option_code_hash_lookup(&option, dhcp_universe.code_hash,

+					      &i, 0, MDL) &&

+		      make_const_option_cache(&oc, NULL,

+					      (u_int8_t *)client_identifier.data,

+					      client_identifier.len,

+					      option, MDL)))

+			log_error ("can't make requested client id cache..");

+		else {

+			save_option (&dhcp_universe, *op, oc);

+			option_cache_dereference (&oc, MDL);

+		}

+		option_dereference(&option, MDL);

+	}

+

 	/* Run statements that need to be run on transmission. */

 	if (client -> config -> on_transmission)

 		execute_statements_in_scope

@@ -4522,6 +4585,7 @@ client_dns_update(struct client_state *client, dhcp_ddns_cb_t *ddns_cb)

 	struct option_cache *oc;

 	int ignorep;

 	int result;

+	int ddns_v4_type;

 	isc_result_t rcode;

 	/* If we didn't send an FQDN option, we certainly aren't going to

@@ -4564,47 +4628,82 @@ client_dns_update(struct client_state *client, dhcp_ddns_cb_t *ddns_cb)

 				    &global_scope, oc, MDL))

 		return ISC_R_SUCCESS;

-	/* If this is a DHCPv6 client update, make a dhcid string out of

-	 * the DUID.  If this is a DHCPv4 client update, choose either

-	 * the client identifier, if there is one, or the interface's

-	 * MAC address.

+        /*

+	 * Construct the DHCID value for use in the DDNS update process

+	 * We have the newer standard version and the older interim version

+	 * chosen by the '-C' option.  The interim version is left as is

+	 * for backwards compatibility.  The standard version is based on

+	 * RFC 4701 section 3.3

 	 */

+

 	result = 0;

 	memset(&client_identifier, 0, sizeof(client_identifier));

-	if (client->active_lease != NULL) {

-		if (((oc =

-		      lookup_option(&dhcpv6_universe, client->sent_options,

-				    D6O_CLIENTID)) != NULL) &&

-		    evaluate_option_cache(&client_identifier, NULL, NULL,

-					  client, client->sent_options, NULL,

+

+        if (std_dhcid == 1) {

+          /* standard style */

+          ddns_cb->dhcid_class = dns_rdatatype_dhcid;

+          ddns_v4_type = 1;

+	} else {

+          /* interim style */

+          ddns_cb->dhcid_class = dns_rdatatype_txt;

+          /* for backwards compatibility */

+          ddns_v4_type = DHO_DHCP_CLIENT_IDENTIFIER;

+	}

+

+        	if (client->active_lease != NULL) {

+		/* V6 request, get the client identifier, then

+		 * construct the dhcid for either standard 

+		 * or interim */

+		if (((oc = lookup_option(&dhcpv6_universe,

+					 client->sent_options,

+					 D6O_CLIENTID)) != NULL) &&

+		    evaluate_option_cache(&client_identifier, NULL,

+					  NULL, client,

+					  client->sent_options, NULL,

 					  &global_scope, oc, MDL)) {

-			/* RFC4701 defines type '2' as being for the DUID

-			 * field.  We aren't using RFC4701 DHCID RR's yet,

-			 * but this is as good a value as any.

-			 */

-			result = get_dhcid(&ddns_cb->dhcid, 2,

+			result = get_dhcid(ddns_cb, 2,

 					   client_identifier.data,

 					   client_identifier.len);

 			data_string_forget(&client_identifier, MDL);

 		} else

 			log_fatal("Impossible condition at %s:%d.", MDL);

 	} else {

-		if (((oc =

-		      lookup_option(&dhcp_universe, client->sent_options,

-				    DHO_DHCP_CLIENT_IDENTIFIER)) != NULL) &&

-		    evaluate_option_cache(&client_identifier, NULL, NULL,

-					  client, client->sent_options, NULL,

+		/*

+		 * V4 request, use the client id if there is one or the

+		 * mac address if there isn't.  If we have a client id

+		 * we check to see if it is an embedded DUID.

+		 */

+		if (((oc = lookup_option(&dhcp_universe,

+					 client->sent_options,

+					 DHO_DHCP_CLIENT_IDENTIFIER)) != NULL) &&

+		    evaluate_option_cache(&client_identifier, NULL,

+					  NULL, client,

+					  client->sent_options, NULL,

 					  &global_scope, oc, MDL)) {

-			result = get_dhcid(&ddns_cb->dhcid,

-					   DHO_DHCP_CLIENT_IDENTIFIER,

-					   client_identifier.data,

-					   client_identifier.len);

+			if ((std_dhcid == 1) && (duid_v4 == 1) &&

+			    (client_identifier.data[0] == 255)) {

+				/*

+				 * This appears to be an embedded DUID,

+				 * extract it and treat it as such

+				 */

+				if (client_identifier.len <= 5)

+					log_fatal("Impossible condition at %s:%d.",

+						  MDL);

+				result = get_dhcid(ddns_cb, 2,

+						   client_identifier.data + 5,

+						   client_identifier.len - 5);

+			} else {

+				result = get_dhcid(ddns_cb, ddns_v4_type,

+						   client_identifier.data,

+						   client_identifier.len);

+			}

 			data_string_forget(&client_identifier, MDL);

 		} else

-			result = get_dhcid(&ddns_cb->dhcid, 0,

+			result = get_dhcid(ddns_cb, 0,

 					   client->interface->hw_address.hbuf,

 					   client->interface->hw_address.hlen);

 	}

+

 	if (!result) {

 		return ISC_R_SUCCESS;

 	}

@@ -4886,3 +4985,4 @@ dhclient_ddns_cb_free(dhcp_ddns_cb_t *ddns_cb, char* file, int line) {

         ddns_cb_free(ddns_cb, file, line);

     }

 }

+

diff --git a/common/conflex.c b/common/conflex.c

index 4611616..c99732e 100644

--- a/common/conflex.c

+++ b/common/conflex.c

@@ -879,10 +879,6 @@ intern(char *atom, enum dhcp_token dfv) {

 	      case 'd':

 		if (!strcasecmp(atom + 1, "b-time-format"))

 			return DB_TIME_FORMAT;

-		if (!strcasecmp (atom + 1, "ns-update"))

-			return DNS_UPDATE;

-		if (!strcasecmp (atom + 1, "ns-delete"))

-			return DNS_DELETE;

 		if (!strcasecmp (atom + 1, "omain"))

 			return DOMAIN;

 		if (!strncasecmp (atom + 1, "omain-", 6)) {

@@ -1178,8 +1174,6 @@ intern(char *atom, enum dhcp_token dfv) {

 			return TOKEN_NOT;

 		if (!strcasecmp (atom + 1, "o"))

 			return TOKEN_NO;

-		if (!strcasecmp (atom + 1, "s-update"))

-			return NS_UPDATE;

 		if (!strcasecmp (atom + 1, "oerror"))

 			return NS_NOERROR;

 		if (!strcasecmp (atom + 1, "otauth"))

@@ -1496,8 +1490,6 @@ intern(char *atom, enum dhcp_token dfv) {

 		}

 		if (!strcasecmp (atom + 1, "nauthenticated"))

 			return UNAUTHENTICATED;

-		if (!strcasecmp (atom + 1, "pdated-dns-rr"))

-			return UPDATED_DNS_RR;

 		if (!strcasecmp (atom + 1, "pdate"))

 			return UPDATE;

 		break;

diff --git a/common/dns.c b/common/dns.c

index d3ac966..a04c61d 100644

--- a/common/dns.c

+++ b/common/dns.c

@@ -30,10 +30,12 @@

  * asynchronous DNS routines.

  */

+/*! \file common/dns.c

+ */

 #include "dhcpd.h"

 #include "arpa/nameser.h"

 #include <isc/md5.h>

-

+#include <isc/sha2.h>

 #include <dns/result.h>

 /*

@@ -823,45 +825,123 @@ void repudiate_zone (struct dns_zone **zone)

 	dns_zone_dereference (zone, MDL);

 }

-/* Have to use TXT records for now. */

-#define T_DHCID T_TXT

+/*!

+ * \brief Create an id for a client

+ *

+ * This function is used to create an id for a client to use with DDNS

+ * This version of the function is for the standard style, RFC 4701

+ *

+ * This function takes information from the type and data fields and

+ * mangles it into a dhcid string which it places in ddns_cb.  It also

+ * sets a field in ddns_cb to specify the class that should be used

+ * when sending the dhcid, in this case it is a DHCID record so we use

+ * dns_rdatatype_dhcid

+ *

+ * The DHCID we construct is:

+ *  2 bytes - identifier type (see 4701 and IANA)

+ *  1 byte  - digest type, currently only SHA256 (1)

+ *  n bytes - digest, length depends on digest type, currently 32 for

+ *            SHA256

+ *

+ * What we base the digest on is up to the calling code for an id type of

+ * 0 - 1 octet htype followed by hlen octets of chaddr from v4 client request

+ * 1 - data octets from a dhcpv4 client's client identifier option

+ * 2 - the client DUID from a v4 or v6 client's client id option

+ * This identifier is concatenated with the fqdn and the result is digested.

+ */

+int get_std_dhcid(dhcp_ddns_cb_t *ddns_cb,

+		  int type,

+		  const u_int8_t *identifier,

+		  unsigned id_len)

+{

+	struct data_string *id = &ddns_cb->dhcid;

+	isc_sha256_t sha256;

+	unsigned char buf[ISC_SHA256_DIGESTLENGTH];

+	unsigned char fwd_buf[256];

+	unsigned fwd_buflen = 0;

+

+	/* Types can only be 0..(2^16)-1. */

+	if (type < 0 || type > 65535)

+		return (0);

+

+	/* We need to convert the fwd name to wire representation */

+	if (MRns_name_pton((char *)ddns_cb->fwd_name.data, fwd_buf, 256) == -1)

+		return (0);

+	while(fwd_buf[fwd_buflen] != 0) {

+		fwd_buflen += fwd_buf[fwd_buflen] + 1;

+	}

+	fwd_buflen++;

+

+	if (!buffer_allocate(&id->buffer,

+			     ISC_SHA256_DIGESTLENGTH + 2 + 1,

+			     MDL))

+		return (0);

+	id->data = id->buffer->data;

+

+	/* The two first bytes contain the type identifier. */

+	putUShort(id->buffer->data, (unsigned)type);

+

+	/* The next is the digest type, SHA-256 is 1 */

+	putUChar(id->buffer->data + 2, 1u);

+

+	/* Computing the digest */

+	isc_sha256_init(&sha256);

+	isc_sha256_update(&sha256, identifier, id_len);

+	isc_sha256_update(&sha256, fwd_buf, fwd_buflen);

+	isc_sha256_final(buf, &sha256);

-int get_dhcid (struct data_string *id,

-	       int type, const u_int8_t *data, unsigned len)

+	memcpy(id->buffer->data + 3, &buf, ISC_SHA256_DIGESTLENGTH);

+

+	id->len = ISC_SHA256_DIGESTLENGTH + 2 + 1;

+

+	return (1);

+}

+

+/*!

+ *

+ * \brief Create an id for a client

+ *

+ * This function is used to create an id for a client to use with DDNS

+ * This version of the function is for the interim style.  It is retained

+ * to allow users to continue using the interim style but they should

+ * switch to the standard style (which uses get_std_dhcid) for better

+ * interoperability.  

+ *

+ * This function takes information from the type and data fields and

+ * mangles it into a dhcid string which it places in ddns_cb.  It also

+ * sets a field in ddns_cb to specify the class that should be used

+ * when sending the dhcid, in this case it is a txt record so we use

+ * dns_rdata_type_txt

+ *

+ * NOTE WELL: this function has issues with how it calculates the

+ * dhcid, they can't be changed now as that would break the records

+ * already in use.

+ */

+

+int get_int_dhcid (dhcp_ddns_cb_t *ddns_cb,

+		   int type,

+		   const u_int8_t *data,

+		   unsigned len)

 {

+	struct data_string *id = &ddns_cb->dhcid;

 	unsigned char buf[ISC_MD5_DIGESTLENGTH];

 	isc_md5_t md5;

 	int i;

 	/* Types can only be 0..(2^16)-1. */

 	if (type < 0 || type > 65535)

-		return 0;

+		return (0);

 	/*

 	 * Hexadecimal MD5 digest plus two byte type, NUL,

 	 * and one byte for length for dns.

 	 */

-	if (!buffer_allocate (&id -> buffer,

-			      (ISC_MD5_DIGESTLENGTH * 2) + 4, MDL))

-		return 0;

-	id -> data = id -> buffer -> data;

+	if (!buffer_allocate(&id -> buffer,

+			     (ISC_MD5_DIGESTLENGTH * 2) + 4, MDL))

+		return (0);

+	id->data = id->buffer->data;

 	/*

-	 * DHCP clients and servers should use the following forms of client

-	 * identification, starting with the most preferable, and finishing

-	 * with the least preferable.  If the client does not send any of these

-	 * forms of identification, the DHCP/DDNS interaction is not defined by

-	 * this specification.  The most preferable form of identification is

-	 * the Globally Unique Identifier Option [TBD].  Next is the DHCP

-	 * Client Identifier option.  Last is the client's link-layer address,

-	 * as conveyed in its DHCPREQUEST message.  Implementors should note

-	 * that the link-layer address cannot be used if there are no

-	 * significant bytes in the chaddr field of the DHCP client's request,

-	 * because this does not constitute a unique identifier.

-	 *   -- "Interaction between DHCP and DNS"

-	 *      <draft-ietf-dhc-dhcp-dns-12.txt>

-	 *      M. Stapp, Y. Rekhter

-	 *

 	 * We put the length into the first byte to turn 

 	 * this into a dns text string.  This avoid needing to

 	 * copy the string to add the byte later.

@@ -893,7 +973,18 @@ int get_dhcid (struct data_string *id,

 	id->buffer->data[id->len] = 0;

 	id->terminated = 1;

-	return 1;

+	return (1);

+}

+

+int get_dhcid(dhcp_ddns_cb_t *ddns_cb,

+	      int type,

+	      const u_int8_t *identifier,

+	      unsigned id_len)

+{

+	if (ddns_cb->dhcid_class == dns_rdatatype_dhcid)

+		return get_std_dhcid(ddns_cb, type, identifier, id_len);

+	else 

+		return get_int_dhcid(ddns_cb, type, identifier, id_len);

 }

 /*

@@ -1015,12 +1106,12 @@ make_dns_dataset(dns_rdataclass_t  dataclass,

  * For the server the first step will have a request of:

  * The name is not in use

  * Add an A RR

- * Add a DHCID RR (currently txt)

+ * Add a DHCID RR

  *

  * For the client the first step will have a request of:

  * The A RR does not exist

  * Add an A RR

- * Add a DHCID RR (currently txt)

+ * Add a DHCID RR

  */

 static isc_result_t

@@ -1062,7 +1153,7 @@ ddns_modify_fwd_add1(dhcp_ddns_cb_t   *ddns_cb,

 	dataspace++;

 	/* Add the DHCID RR */

-	result = make_dns_dataset(dns_rdataclass_in, dns_rdatatype_txt,

+	result = make_dns_dataset(dns_rdataclass_in, ddns_cb->dhcid_class,

 				  dataspace, 

 				  (unsigned char *)ddns_cb->dhcid.data,

 				  ddns_cb->dhcid.len, ddns_cb->ttl);

@@ -1108,7 +1199,7 @@ ddns_modify_fwd_add2(dhcp_ddns_cb_t   *ddns_cb,

 		     dns_name_t       *pname,

 		     dns_name_t       *uname)

 {

-	isc_result_t result;

+	isc_result_t result = ISC_R_SUCCESS;

 	/*

 	 * If we are doing conflict resolution (unset) we use a prereq list.

@@ -1117,7 +1208,7 @@ ddns_modify_fwd_add2(dhcp_ddns_cb_t   *ddns_cb,

 	if ((ddns_cb->flags & DDNS_CONFLICT_OVERRIDE) == 0) {

 		/* Construct the prereq list */

 		/* The DHCID RR exists and matches the client identity */

-		result = make_dns_dataset(dns_rdataclass_in, dns_rdatatype_txt,

+		result = make_dns_dataset(dns_rdataclass_in, ddns_cb->dhcid_class,

 					  dataspace, 

 					  (unsigned char *)ddns_cb->dhcid.data,

 					  ddns_cb->dhcid.len, 0);

@@ -1130,7 +1221,7 @@ ddns_modify_fwd_add2(dhcp_ddns_cb_t   *ddns_cb,

 		/* Start constructing the update list.

 		 * Conflict detection override: delete DHCID RRs */

 		result = make_dns_dataset(dns_rdataclass_any,

-					  dns_rdatatype_txt,

+					  ddns_cb->dhcid_class,

 					  dataspace, NULL, 0, 0);

 		if (result != ISC_R_SUCCESS) {

 			return(result);

@@ -1139,7 +1230,7 @@ ddns_modify_fwd_add2(dhcp_ddns_cb_t   *ddns_cb,

 		dataspace++;

 		/* Add current DHCID RR */

-		result = make_dns_dataset(dns_rdataclass_in, dns_rdatatype_txt,

+		result = make_dns_dataset(dns_rdataclass_in, ddns_cb->dhcid_class,

 					  dataspace, 

 					  (unsigned char *)ddns_cb->dhcid.data,

 					  ddns_cb->dhcid.len, ddns_cb->ttl);

@@ -1201,11 +1292,11 @@ ddns_modify_fwd_rem1(dhcp_ddns_cb_t   *ddns_cb,

 		     dns_name_t       *pname,

 		     dns_name_t       *uname)

 {

-	isc_result_t result;

+	isc_result_t result = ISC_R_SUCCESS;

 	/* Consruct the prereq list */

 	/* The DHCID RR exists and matches the client identity */

-	result = make_dns_dataset(dns_rdataclass_in, dns_rdatatype_txt,

+	result = make_dns_dataset(dns_rdataclass_in, ddns_cb->dhcid_class,

 				  dataspace, 

 				  (unsigned char *)ddns_cb->dhcid.data,

 				  ddns_cb->dhcid.len, 0);

@@ -1271,7 +1362,7 @@ ddns_modify_fwd_rem2(dhcp_ddns_cb_t   *ddns_cb,

 	/* Construct the update list */

 	/* Delete DHCID RR */

-	result = make_dns_dataset(dns_rdataclass_none, dns_rdatatype_txt,

+	result = make_dns_dataset(dns_rdataclass_none, ddns_cb->dhcid_class,

 				  dataspace,

 				  (unsigned char *)ddns_cb->dhcid.data,

 				  ddns_cb->dhcid.len, 0);

diff --git a/common/parse.c b/common/parse.c

index fc51327..7477543 100644

--- a/common/parse.c

+++ b/common/parse.c

@@ -3558,42 +3558,7 @@ int parse_numeric_expression (expr, cfile, lose)

 	}

 	return 1;

 }

-#if defined (NSUPDATE_OLD)

-/*

- * dns-expression :==

- *	UPDATE LPAREN ns-class COMMA ns-type COMMA data-expression COMMA

- *				data-expression COMMA numeric-expression RPAREN

- *	DELETE LPAREN ns-class COMMA ns-type COMMA data-expression COMMA

- *				data-expression RPAREN

- *	EXISTS LPAREN ns-class COMMA ns-type COMMA data-expression COMMA

- *				data-expression RPAREN

- *	NOT EXISTS LPAREN ns-class COMMA ns-type COMMA data-expression COMMA

- *				data-expression RPAREN