diff --git a/ndn-cpp/c/encoding/BinaryXML.h b/ndn-cpp/c/encoding/BinaryXML.h
index 587b2fc..eb5d2b4 100644
--- a/ndn-cpp/c/encoding/BinaryXML.h
+++ b/ndn-cpp/c/encoding/BinaryXML.h
@@ -11,130 +11,130 @@
 #endif
 
 enum {
-  ndn_BinaryXML_EXT = 0x00, 	
-  ndn_BinaryXML_TAG = 0x01, 
-  ndn_BinaryXML_DTAG = 0x02, 
-  ndn_BinaryXML_ATTR = 0x03, 
-  ndn_BinaryXML_DATTR = 0x04, 
-  ndn_BinaryXML_BLOB = 0x05, 
-  ndn_BinaryXML_UDATA = 0x06, 
-  ndn_BinaryXML_CLOSE = 0x0,
+  ndn_BinaryXml_EXT = 0x00, 	
+  ndn_BinaryXml_TAG = 0x01, 
+  ndn_BinaryXml_DTAG = 0x02, 
+  ndn_BinaryXml_ATTR = 0x03, 
+  ndn_BinaryXml_DATTR = 0x04, 
+  ndn_BinaryXml_BLOB = 0x05, 
+  ndn_BinaryXml_UDATA = 0x06, 
+  ndn_BinaryXml_CLOSE = 0x0,
 
-  ndn_BinaryXML_TT_BITS = 3,
-  ndn_BinaryXML_TT_MASK = ((1 << ndn_BinaryXML_TT_BITS) - 1),
-  ndn_BinaryXML_TT_VALUE_BITS = 4,
-  ndn_BinaryXML_TT_VALUE_MASK = ((1 << (ndn_BinaryXML_TT_VALUE_BITS)) - 1),
-  ndn_BinaryXML_REGULAR_VALUE_BITS = 7,
-  ndn_BinaryXML_REGULAR_VALUE_MASK = ((1 << ndn_BinaryXML_REGULAR_VALUE_BITS) - 1),
-  ndn_BinaryXML_TT_FINAL = 0x80,
+  ndn_BinaryXml_TT_BITS = 3,
+  ndn_BinaryXml_TT_MASK = ((1 << ndn_BinaryXml_TT_BITS) - 1),
+  ndn_BinaryXml_TT_VALUE_BITS = 4,
+  ndn_BinaryXml_TT_VALUE_MASK = ((1 << (ndn_BinaryXml_TT_VALUE_BITS)) - 1),
+  ndn_BinaryXml_REGULAR_VALUE_BITS = 7,
+  ndn_BinaryXml_REGULAR_VALUE_MASK = ((1 << ndn_BinaryXml_REGULAR_VALUE_BITS) - 1),
+  ndn_BinaryXml_TT_FINAL = 0x80,
 
-  ndn_BinaryXML_DTag_Any = 13,
-  ndn_BinaryXML_DTag_Name = 14,
-  ndn_BinaryXML_DTag_Component = 15,
-  ndn_BinaryXML_DTag_Certificate = 16,
-  ndn_BinaryXML_DTag_Collection = 17,
-  ndn_BinaryXML_DTag_CompleteName = 18,
-  ndn_BinaryXML_DTag_Content = 19,
-  ndn_BinaryXML_DTag_SignedInfo = 20,
-  ndn_BinaryXML_DTag_ContentDigest = 21,
-  ndn_BinaryXML_DTag_ContentHash = 22,
-  ndn_BinaryXML_DTag_Count = 24,
-  ndn_BinaryXML_DTag_Header = 25,
-  ndn_BinaryXML_DTag_Interest = 26,	/* 20090915 */
-  ndn_BinaryXML_DTag_Key = 27,
-  ndn_BinaryXML_DTag_KeyLocator = 28,
-  ndn_BinaryXML_DTag_KeyName = 29,
-  ndn_BinaryXML_DTag_Length = 30,
-  ndn_BinaryXML_DTag_Link = 31,
-  ndn_BinaryXML_DTag_LinkAuthenticator = 32,
-  ndn_BinaryXML_DTag_NameComponentCount = 33,	/* DeprecatedInInterest */
-  ndn_BinaryXML_DTag_RootDigest = 36,
-  ndn_BinaryXML_DTag_Signature = 37,
-  ndn_BinaryXML_DTag_Start = 38,
-  ndn_BinaryXML_DTag_Timestamp = 39,
-  ndn_BinaryXML_DTag_Type = 40,
-  ndn_BinaryXML_DTag_Nonce = 41,
-  ndn_BinaryXML_DTag_Scope = 42,
-  ndn_BinaryXML_DTag_Exclude = 43,
-  ndn_BinaryXML_DTag_Bloom = 44,
-  ndn_BinaryXML_DTag_BloomSeed = 45,
-  ndn_BinaryXML_DTag_AnswerOriginKind = 47,
-  ndn_BinaryXML_DTag_InterestLifetime = 48,
-  ndn_BinaryXML_DTag_Witness = 53,
-  ndn_BinaryXML_DTag_SignatureBits = 54,
-  ndn_BinaryXML_DTag_DigestAlgorithm = 55,
-  ndn_BinaryXML_DTag_BlockSize = 56,
-  ndn_BinaryXML_DTag_FreshnessSeconds = 58,
-  ndn_BinaryXML_DTag_FinalBlockID = 59,
-  ndn_BinaryXML_DTag_PublisherPublicKeyDigest = 60,
-  ndn_BinaryXML_DTag_PublisherCertificateDigest = 61,
-  ndn_BinaryXML_DTag_PublisherIssuerKeyDigest = 62,
-  ndn_BinaryXML_DTag_PublisherIssuerCertificateDigest = 63,
-  ndn_BinaryXML_DTag_ContentObject = 64,	/* 20090915 */
-  ndn_BinaryXML_DTag_WrappedKey = 65,
-  ndn_BinaryXML_DTag_WrappingKeyIdentifier = 66,
-  ndn_BinaryXML_DTag_WrapAlgorithm = 67,
-  ndn_BinaryXML_DTag_KeyAlgorithm = 68,
-  ndn_BinaryXML_DTag_Label = 69,
-  ndn_BinaryXML_DTag_EncryptedKey = 70,
-  ndn_BinaryXML_DTag_EncryptedNonceKey = 71,
-  ndn_BinaryXML_DTag_WrappingKeyName = 72,
-  ndn_BinaryXML_DTag_Action = 73,
-  ndn_BinaryXML_DTag_FaceID = 74,
-  ndn_BinaryXML_DTag_IPProto = 75,
-  ndn_BinaryXML_DTag_Host = 76,
-  ndn_BinaryXML_DTag_Port = 77,
-  ndn_BinaryXML_DTag_MulticastInterface = 78,
-  ndn_BinaryXML_DTag_ForwardingFlags = 79,
-  ndn_BinaryXML_DTag_FaceInstance = 80,
-  ndn_BinaryXML_DTag_ForwardingEntry = 81,
-  ndn_BinaryXML_DTag_MulticastTTL = 82,
-  ndn_BinaryXML_DTag_MinSuffixComponents = 83,
-  ndn_BinaryXML_DTag_MaxSuffixComponents = 84,
-  ndn_BinaryXML_DTag_ChildSelector = 85,
-  ndn_BinaryXML_DTag_RepositoryInfo = 86,
-  ndn_BinaryXML_DTag_Version = 87,
-  ndn_BinaryXML_DTag_RepositoryVersion = 88,
-  ndn_BinaryXML_DTag_GlobalPrefix = 89,
-  ndn_BinaryXML_DTag_LocalName = 90,
-  ndn_BinaryXML_DTag_Policy = 91,
-  ndn_BinaryXML_DTag_Namespace = 92,
-  ndn_BinaryXML_DTag_GlobalPrefixName = 93,
-  ndn_BinaryXML_DTag_PolicyVersion = 94,
-  ndn_BinaryXML_DTag_KeyValueSet = 95,
-  ndn_BinaryXML_DTag_KeyValuePair = 96,
-  ndn_BinaryXML_DTag_IntegerValue = 97,
-  ndn_BinaryXML_DTag_DecimalValue = 98,
-  ndn_BinaryXML_DTag_StringValue = 99,
-  ndn_BinaryXML_DTag_BinaryValue = 100,
-  ndn_BinaryXML_DTag_NameValue = 101,
-  ndn_BinaryXML_DTag_Entry = 102,
-  ndn_BinaryXML_DTag_ACL = 103,
-  ndn_BinaryXML_DTag_ParameterizedName = 104,
-  ndn_BinaryXML_DTag_Prefix = 105,
-  ndn_BinaryXML_DTag_Suffix = 106,
-  ndn_BinaryXML_DTag_Root = 107,
-  ndn_BinaryXML_DTag_ProfileName = 108,
-  ndn_BinaryXML_DTag_Parameters = 109,
-  ndn_BinaryXML_DTag_InfoString = 110,
-  ndn_BinaryXML_DTag_StatusResponse = 112,
-  ndn_BinaryXML_DTag_StatusCode = 113,
-  ndn_BinaryXML_DTag_StatusText = 114,
-  ndn_BinaryXML_DTag_SyncNode = 115,
-  ndn_BinaryXML_DTag_SyncNodeKind = 116,
-  ndn_BinaryXML_DTag_SyncNodeElement = 117,
-  ndn_BinaryXML_DTag_SyncVersion = 118,
-  ndn_BinaryXML_DTag_SyncNodeElements = 119,
-  ndn_BinaryXML_DTag_SyncContentHash = 120,
-  ndn_BinaryXML_DTag_SyncLeafCount = 121,
-  ndn_BinaryXML_DTag_SyncTreeDepth = 122,
-  ndn_BinaryXML_DTag_SyncByteCount = 123,
-  ndn_BinaryXML_DTag_SyncConfigSlice = 124,
-  ndn_BinaryXML_DTag_SyncConfigSliceList = 125,
-  ndn_BinaryXML_DTag_SyncConfigSliceOp = 126,
-  ndn_BinaryXML_DTag_SyncNodeDeltas = 127,
-  ndn_BinaryXML_DTag_SequenceNumber = 256,
-  ndn_BinaryXML_DTag_CCNProtocolDataUnit = 17702112
+  ndn_BinaryXml_DTag_Any = 13,
+  ndn_BinaryXml_DTag_Name = 14,
+  ndn_BinaryXml_DTag_Component = 15,
+  ndn_BinaryXml_DTag_Certificate = 16,
+  ndn_BinaryXml_DTag_Collection = 17,
+  ndn_BinaryXml_DTag_CompleteName = 18,
+  ndn_BinaryXml_DTag_Content = 19,
+  ndn_BinaryXml_DTag_SignedInfo = 20,
+  ndn_BinaryXml_DTag_ContentDigest = 21,
+  ndn_BinaryXml_DTag_ContentHash = 22,
+  ndn_BinaryXml_DTag_Count = 24,
+  ndn_BinaryXml_DTag_Header = 25,
+  ndn_BinaryXml_DTag_Interest = 26,	/* 20090915 */
+  ndn_BinaryXml_DTag_Key = 27,
+  ndn_BinaryXml_DTag_KeyLocator = 28,
+  ndn_BinaryXml_DTag_KeyName = 29,
+  ndn_BinaryXml_DTag_Length = 30,
+  ndn_BinaryXml_DTag_Link = 31,
+  ndn_BinaryXml_DTag_LinkAuthenticator = 32,
+  ndn_BinaryXml_DTag_NameComponentCount = 33,	/* DeprecatedInInterest */
+  ndn_BinaryXml_DTag_RootDigest = 36,
+  ndn_BinaryXml_DTag_Signature = 37,
+  ndn_BinaryXml_DTag_Start = 38,
+  ndn_BinaryXml_DTag_Timestamp = 39,
+  ndn_BinaryXml_DTag_Type = 40,
+  ndn_BinaryXml_DTag_Nonce = 41,
+  ndn_BinaryXml_DTag_Scope = 42,
+  ndn_BinaryXml_DTag_Exclude = 43,
+  ndn_BinaryXml_DTag_Bloom = 44,
+  ndn_BinaryXml_DTag_BloomSeed = 45,
+  ndn_BinaryXml_DTag_AnswerOriginKind = 47,
+  ndn_BinaryXml_DTag_InterestLifetime = 48,
+  ndn_BinaryXml_DTag_Witness = 53,
+  ndn_BinaryXml_DTag_SignatureBits = 54,
+  ndn_BinaryXml_DTag_DigestAlgorithm = 55,
+  ndn_BinaryXml_DTag_BlockSize = 56,
+  ndn_BinaryXml_DTag_FreshnessSeconds = 58,
+  ndn_BinaryXml_DTag_FinalBlockID = 59,
+  ndn_BinaryXml_DTag_PublisherPublicKeyDigest = 60,
+  ndn_BinaryXml_DTag_PublisherCertificateDigest = 61,
+  ndn_BinaryXml_DTag_PublisherIssuerKeyDigest = 62,
+  ndn_BinaryXml_DTag_PublisherIssuerCertificateDigest = 63,
+  ndn_BinaryXml_DTag_ContentObject = 64,	/* 20090915 */
+  ndn_BinaryXml_DTag_WrappedKey = 65,
+  ndn_BinaryXml_DTag_WrappingKeyIdentifier = 66,
+  ndn_BinaryXml_DTag_WrapAlgorithm = 67,
+  ndn_BinaryXml_DTag_KeyAlgorithm = 68,
+  ndn_BinaryXml_DTag_Label = 69,
+  ndn_BinaryXml_DTag_EncryptedKey = 70,
+  ndn_BinaryXml_DTag_EncryptedNonceKey = 71,
+  ndn_BinaryXml_DTag_WrappingKeyName = 72,
+  ndn_BinaryXml_DTag_Action = 73,
+  ndn_BinaryXml_DTag_FaceID = 74,
+  ndn_BinaryXml_DTag_IPProto = 75,
+  ndn_BinaryXml_DTag_Host = 76,
+  ndn_BinaryXml_DTag_Port = 77,
+  ndn_BinaryXml_DTag_MulticastInterface = 78,
+  ndn_BinaryXml_DTag_ForwardingFlags = 79,
+  ndn_BinaryXml_DTag_FaceInstance = 80,
+  ndn_BinaryXml_DTag_ForwardingEntry = 81,
+  ndn_BinaryXml_DTag_MulticastTTL = 82,
+  ndn_BinaryXml_DTag_MinSuffixComponents = 83,
+  ndn_BinaryXml_DTag_MaxSuffixComponents = 84,
+  ndn_BinaryXml_DTag_ChildSelector = 85,
+  ndn_BinaryXml_DTag_RepositoryInfo = 86,
+  ndn_BinaryXml_DTag_Version = 87,
+  ndn_BinaryXml_DTag_RepositoryVersion = 88,
+  ndn_BinaryXml_DTag_GlobalPrefix = 89,
+  ndn_BinaryXml_DTag_LocalName = 90,
+  ndn_BinaryXml_DTag_Policy = 91,
+  ndn_BinaryXml_DTag_Namespace = 92,
+  ndn_BinaryXml_DTag_GlobalPrefixName = 93,
+  ndn_BinaryXml_DTag_PolicyVersion = 94,
+  ndn_BinaryXml_DTag_KeyValueSet = 95,
+  ndn_BinaryXml_DTag_KeyValuePair = 96,
+  ndn_BinaryXml_DTag_IntegerValue = 97,
+  ndn_BinaryXml_DTag_DecimalValue = 98,
+  ndn_BinaryXml_DTag_StringValue = 99,
+  ndn_BinaryXml_DTag_BinaryValue = 100,
+  ndn_BinaryXml_DTag_NameValue = 101,
+  ndn_BinaryXml_DTag_Entry = 102,
+  ndn_BinaryXml_DTag_ACL = 103,
+  ndn_BinaryXml_DTag_ParameterizedName = 104,
+  ndn_BinaryXml_DTag_Prefix = 105,
+  ndn_BinaryXml_DTag_Suffix = 106,
+  ndn_BinaryXml_DTag_Root = 107,
+  ndn_BinaryXml_DTag_ProfileName = 108,
+  ndn_BinaryXml_DTag_Parameters = 109,
+  ndn_BinaryXml_DTag_InfoString = 110,
+  ndn_BinaryXml_DTag_StatusResponse = 112,
+  ndn_BinaryXml_DTag_StatusCode = 113,
+  ndn_BinaryXml_DTag_StatusText = 114,
+  ndn_BinaryXml_DTag_SyncNode = 115,
+  ndn_BinaryXml_DTag_SyncNodeKind = 116,
+  ndn_BinaryXml_DTag_SyncNodeElement = 117,
+  ndn_BinaryXml_DTag_SyncVersion = 118,
+  ndn_BinaryXml_DTag_SyncNodeElements = 119,
+  ndn_BinaryXml_DTag_SyncContentHash = 120,
+  ndn_BinaryXml_DTag_SyncLeafCount = 121,
+  ndn_BinaryXml_DTag_SyncTreeDepth = 122,
+  ndn_BinaryXml_DTag_SyncByteCount = 123,
+  ndn_BinaryXml_DTag_SyncConfigSlice = 124,
+  ndn_BinaryXml_DTag_SyncConfigSliceList = 125,
+  ndn_BinaryXml_DTag_SyncConfigSliceOp = 126,
+  ndn_BinaryXml_DTag_SyncNodeDeltas = 127,
+  ndn_BinaryXml_DTag_SequenceNumber = 256,
+  ndn_BinaryXml_DTag_CCNProtocolDataUnit = 17702112
 };
 
 #ifdef	__cplusplus
diff --git a/ndn-cpp/c/encoding/BinaryXMLContentObject.c b/ndn-cpp/c/encoding/BinaryXMLContentObject.c
index c9104ff..d95889c 100644
--- a/ndn-cpp/c/encoding/BinaryXMLContentObject.c
+++ b/ndn-cpp/c/encoding/BinaryXMLContentObject.c
@@ -10,67 +10,67 @@
 #include "BinaryXMLPublisherPublicKeyDigest.h"
 #include "BinaryXMLContentObject.h"
 
-static ndn_Error encodeSignature(struct ndn_Signature *signature, struct ndn_BinaryXMLEncoder *encoder)
+static ndn_Error encodeSignature(struct ndn_Signature *signature, struct ndn_BinaryXmlEncoder *encoder)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(encoder, ndn_BinaryXML_DTag_Signature))
+  if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(encoder, ndn_BinaryXml_DTag_Signature))
     return error;
   
   // TODO: Check if digestAlgorithm is the same as the default, and skip it, otherwise encode it as UDATA.
 
-  if (error = ndn_BinaryXMLEncoder_writeOptionalBlobDTagElement
-      (encoder, ndn_BinaryXML_DTag_Witness, signature->witness, signature->witnessLength))
+  if (error = ndn_BinaryXmlEncoder_writeOptionalBlobDTagElement
+      (encoder, ndn_BinaryXml_DTag_Witness, signature->witness, signature->witnessLength))
     return error;
 
   // Require a signature.
-  if (error = ndn_BinaryXMLEncoder_writeBlobDTagElement
-      (encoder, ndn_BinaryXML_DTag_SignatureBits, signature->signature, signature->signatureLength))
+  if (error = ndn_BinaryXmlEncoder_writeBlobDTagElement
+      (encoder, ndn_BinaryXml_DTag_SignatureBits, signature->signature, signature->signatureLength))
     return error;
   
-	if (error = ndn_BinaryXMLEncoder_writeElementClose(encoder))
+	if (error = ndn_BinaryXmlEncoder_writeElementClose(encoder))
     return error;
   
   return 0;    
 }
 
-static ndn_Error decodeSignature(struct ndn_Signature *signature, struct ndn_BinaryXMLDecoder *decoder)
+static ndn_Error decodeSignature(struct ndn_Signature *signature, struct ndn_BinaryXmlDecoder *decoder)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLDecoder_readElementStartDTag(decoder, ndn_BinaryXML_DTag_Signature))
+  if (error = ndn_BinaryXmlDecoder_readElementStartDTag(decoder, ndn_BinaryXml_DTag_Signature))
     return error;
   
   /* TODO: digestAlgorithm as UDATA */ signature->digestAlgorithm = 0; signature->digestAlgorithmLength = 0;
   
-  if (error = ndn_BinaryXMLDecoder_readOptionalBinaryDTagElement
-      (decoder, ndn_BinaryXML_DTag_Witness, 0, &signature->witness, &signature->witnessLength))
+  if (error = ndn_BinaryXmlDecoder_readOptionalBinaryDTagElement
+      (decoder, ndn_BinaryXml_DTag_Witness, 0, &signature->witness, &signature->witnessLength))
     return error;
   
   // Require a signature.
-  if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement
-      (decoder, ndn_BinaryXML_DTag_SignatureBits, 0, &signature->signature, &signature->signatureLength))
+  if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement
+      (decoder, ndn_BinaryXml_DTag_SignatureBits, 0, &signature->signature, &signature->signatureLength))
     return error;
   
-  if (error = ndn_BinaryXMLDecoder_readElementClose(decoder))
+  if (error = ndn_BinaryXmlDecoder_readElementClose(decoder))
     return error;
   
   return 0;
 }
 
-static ndn_Error encodeSignedInfo(struct ndn_SignedInfo *signedInfo, struct ndn_BinaryXMLEncoder *encoder)
+static ndn_Error encodeSignedInfo(struct ndn_SignedInfo *signedInfo, struct ndn_BinaryXmlEncoder *encoder)
 {
   if (signedInfo->type < 0)
     return;
 
   ndn_Error error;
-  if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(encoder, ndn_BinaryXML_DTag_SignedInfo))
+  if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(encoder, ndn_BinaryXml_DTag_SignedInfo))
     return error;
 
   // This will skip encoding if there is no publisherPublicKeyDigest.
-  if (error = ndn_encodeBinaryXMLPublisherPublicKeyDigest(&signedInfo->publisherPublicKeyDigest, encoder))
+  if (error = ndn_encodeBinaryXmlPublisherPublicKeyDigest(&signedInfo->publisherPublicKeyDigest, encoder))
     return error;
   
-  if (error = ndn_BinaryXMLEncoder_writeOptionalTimeMillisecondsDTagElement
-      (encoder, ndn_BinaryXML_DTag_Timestamp, signedInfo->timestampMilliseconds))
+  if (error = ndn_BinaryXmlEncoder_writeOptionalTimeMillisecondsDTagElement
+      (encoder, ndn_BinaryXml_DTag_Timestamp, signedInfo->timestampMilliseconds))
     return error;
   
   if (signedInfo->type != ndn_ContentType_DATA) {
@@ -78,90 +78,90 @@
     // TODO: Implement converting the type from an int and encoding.
   }
   
-  if (error = ndn_BinaryXMLEncoder_writeOptionalUnsignedDecimalIntDTagElement
-      (encoder, ndn_BinaryXML_DTag_FreshnessSeconds, signedInfo->freshnessSeconds))
+  if (error = ndn_BinaryXmlEncoder_writeOptionalUnsignedDecimalIntDTagElement
+      (encoder, ndn_BinaryXml_DTag_FreshnessSeconds, signedInfo->freshnessSeconds))
     return error;
   
-  if (error = ndn_BinaryXMLEncoder_writeOptionalBlobDTagElement
-      (encoder, ndn_BinaryXML_DTag_FinalBlockID, signedInfo->finalBlockID, signedInfo->finalBlockIDLength))
+  if (error = ndn_BinaryXmlEncoder_writeOptionalBlobDTagElement
+      (encoder, ndn_BinaryXml_DTag_FinalBlockID, signedInfo->finalBlockID, signedInfo->finalBlockIDLength))
     return error;
  
   // This will skip encoding if there is no key locator.
-  if (error = ndn_encodeBinaryXMLKeyLocator(&signedInfo->keyLocator, encoder))
+  if (error = ndn_encodeBinaryXmlKeyLocator(&signedInfo->keyLocator, encoder))
     return error;
   
-	if (error = ndn_BinaryXMLEncoder_writeElementClose(encoder))
+	if (error = ndn_BinaryXmlEncoder_writeElementClose(encoder))
     return error;
   
   return 0;  
 }
 
-static ndn_Error decodeSignedInfo(struct ndn_SignedInfo *signedInfo, struct ndn_BinaryXMLDecoder *decoder)
+static ndn_Error decodeSignedInfo(struct ndn_SignedInfo *signedInfo, struct ndn_BinaryXmlDecoder *decoder)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLDecoder_readElementStartDTag(decoder, ndn_BinaryXML_DTag_SignedInfo))
+  if (error = ndn_BinaryXmlDecoder_readElementStartDTag(decoder, ndn_BinaryXml_DTag_SignedInfo))
     return error;
   
-  if (error = ndn_decodeOptionalBinaryXMLPublisherPublicKeyDigest(&signedInfo->publisherPublicKeyDigest, decoder))
+  if (error = ndn_decodeOptionalBinaryXmlPublisherPublicKeyDigest(&signedInfo->publisherPublicKeyDigest, decoder))
     return error;
   
-  if (error= ndn_BinaryXMLDecoder_readOptionalTimeMillisecondsDTagElement
-      (decoder, ndn_BinaryXML_DTag_Timestamp, &signedInfo->timestampMilliseconds))
+  if (error= ndn_BinaryXmlDecoder_readOptionalTimeMillisecondsDTagElement
+      (decoder, ndn_BinaryXml_DTag_Timestamp, &signedInfo->timestampMilliseconds))
     return error;
   
   // TODO: Implement reading the type and converting to an int.
   signedInfo->type = ndn_ContentType_DATA;
  
-  if (error = ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement
-      (decoder, ndn_BinaryXML_DTag_FreshnessSeconds, &signedInfo->freshnessSeconds))
+  if (error = ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+      (decoder, ndn_BinaryXml_DTag_FreshnessSeconds, &signedInfo->freshnessSeconds))
     return error;
 
-  if (error = ndn_BinaryXMLDecoder_readOptionalBinaryDTagElement
-      (decoder, ndn_BinaryXML_DTag_FinalBlockID, 0, &signedInfo->finalBlockID, &signedInfo->finalBlockIDLength))
+  if (error = ndn_BinaryXmlDecoder_readOptionalBinaryDTagElement
+      (decoder, ndn_BinaryXml_DTag_FinalBlockID, 0, &signedInfo->finalBlockID, &signedInfo->finalBlockIDLength))
     return error;
 
-  if (error = ndn_decodeOptionalBinaryXMLKeyLocator(&signedInfo->keyLocator, decoder))
+  if (error = ndn_decodeOptionalBinaryXmlKeyLocator(&signedInfo->keyLocator, decoder))
     return error;
   
-  if (error = ndn_BinaryXMLDecoder_readElementClose(decoder))
+  if (error = ndn_BinaryXmlDecoder_readElementClose(decoder))
     return error;
   
   return 0;
 }
 
-ndn_Error ndn_encodeBinaryXMLContentObject(struct ndn_ContentObject *contentObject, struct ndn_BinaryXMLEncoder *encoder)
+ndn_Error ndn_encodeBinaryXmlContentObject(struct ndn_ContentObject *contentObject, struct ndn_BinaryXmlEncoder *encoder)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(encoder, ndn_BinaryXML_DTag_ContentObject))
+  if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(encoder, ndn_BinaryXml_DTag_ContentObject))
     return error;
   
   if (error = encodeSignature(&contentObject->signature, encoder))
     return 0;
 
-  if (error = ndn_encodeBinaryXMLName(&contentObject->name, encoder))
+  if (error = ndn_encodeBinaryXmlName(&contentObject->name, encoder))
     return error;
 
   if (error = encodeSignedInfo(&contentObject->signedInfo, encoder))
     return 0;
 
-  if (error = ndn_BinaryXMLEncoder_writeBlobDTagElement
-      (encoder, ndn_BinaryXML_DTag_Content, contentObject->content, contentObject->contentLength))
+  if (error = ndn_BinaryXmlEncoder_writeBlobDTagElement
+      (encoder, ndn_BinaryXml_DTag_Content, contentObject->content, contentObject->contentLength))
     return error;
   
-	if (error = ndn_BinaryXMLEncoder_writeElementClose(encoder))
+	if (error = ndn_BinaryXmlEncoder_writeElementClose(encoder))
     return error;
   
   return 0;
 }
 
-ndn_Error ndn_decodeBinaryXMLContentObject(struct ndn_ContentObject *contentObject, struct ndn_BinaryXMLDecoder *decoder)
+ndn_Error ndn_decodeBinaryXmlContentObject(struct ndn_ContentObject *contentObject, struct ndn_BinaryXmlDecoder *decoder)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLDecoder_readElementStartDTag(decoder, ndn_BinaryXML_DTag_ContentObject))
+  if (error = ndn_BinaryXmlDecoder_readElementStartDTag(decoder, ndn_BinaryXml_DTag_ContentObject))
     return error;
 
   int gotExpectedTag;
-  if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_Signature, &gotExpectedTag))
+  if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_Signature, &gotExpectedTag))
     return error;
   if (gotExpectedTag) {
     if (error = decodeSignature(&contentObject->signature, decoder))
@@ -170,10 +170,10 @@
   else
     ndn_Signature_init(&contentObject->signature);
   
-  if (error = ndn_decodeBinaryXMLName(&contentObject->name, decoder))
+  if (error = ndn_decodeBinaryXmlName(&contentObject->name, decoder))
     return error;
   
-  if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_SignedInfo, &gotExpectedTag))
+  if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_SignedInfo, &gotExpectedTag))
     return error;
   if (gotExpectedTag) {
     if (error = decodeSignedInfo(&contentObject->signedInfo, decoder))
@@ -183,11 +183,11 @@
     ndn_SignedInfo_init(&contentObject->signedInfo);
 
   // Require a Content element, but set allowNull to allow a missing BLOB.
-  if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement
-      (decoder, ndn_BinaryXML_DTag_Content, 1, &contentObject->content, &contentObject->contentLength))
+  if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement
+      (decoder, ndn_BinaryXml_DTag_Content, 1, &contentObject->content, &contentObject->contentLength))
     return error; 
   
-  if (error = ndn_BinaryXMLDecoder_readElementClose(decoder))
+  if (error = ndn_BinaryXmlDecoder_readElementClose(decoder))
     return error;
   
   return 0;
diff --git a/ndn-cpp/c/encoding/BinaryXMLContentObject.h b/ndn-cpp/c/encoding/BinaryXMLContentObject.h
index b6444bb..eb7cc5e 100644
--- a/ndn-cpp/c/encoding/BinaryXMLContentObject.h
+++ b/ndn-cpp/c/encoding/BinaryXMLContentObject.h
@@ -15,9 +15,9 @@
 extern "C" {
 #endif
 
-ndn_Error ndn_encodeBinaryXMLContentObject(struct ndn_ContentObject *contentObject, struct ndn_BinaryXMLEncoder *encoder);
+ndn_Error ndn_encodeBinaryXmlContentObject(struct ndn_ContentObject *contentObject, struct ndn_BinaryXmlEncoder *encoder);
 
-ndn_Error ndn_decodeBinaryXMLContentObject(struct ndn_ContentObject *contentObject, struct ndn_BinaryXMLDecoder *decoder);
+ndn_Error ndn_decodeBinaryXmlContentObject(struct ndn_ContentObject *contentObject, struct ndn_BinaryXmlDecoder *decoder);
 
 #ifdef	__cplusplus
 }
diff --git a/ndn-cpp/c/encoding/BinaryXMLDecoder.c b/ndn-cpp/c/encoding/BinaryXMLDecoder.c
index 23dd67d..a44af26 100644
--- a/ndn-cpp/c/encoding/BinaryXMLDecoder.c
+++ b/ndn-cpp/c/encoding/BinaryXMLDecoder.c
@@ -11,7 +11,7 @@
  * Return the octet at self->offset, converting to unsigned int.  Increment self->offset.
  * This does not check for reading past the end of the input, so this is called "unsafe".
  */
-static inline unsigned int unsafeReadOctet(struct ndn_BinaryXMLDecoder *self) 
+static inline unsigned int unsafeReadOctet(struct ndn_BinaryXmlDecoder *self) 
 {
   return (unsigned int)(self->input[self->offset++] & 0xff);  
 }
@@ -20,7 +20,7 @@
  * Return the octet at self->offset, converting to unsigned int.  Do not increment self->offset.
  * This does not check for reading past the end of the input, so this is called "unsafe".
  */
-static inline unsigned int unsafeGetOctet(struct ndn_BinaryXMLDecoder *self) 
+static inline unsigned int unsafeGetOctet(struct ndn_BinaryXmlDecoder *self) 
 {
   return (unsigned int)(self->input[self->offset] & 0xff);  
 }
@@ -51,7 +51,7 @@
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLDecoder_decodeTypeAndValue(struct ndn_BinaryXMLDecoder *self, unsigned int *type, unsigned int *valueOut) 
+ndn_Error ndn_BinaryXmlDecoder_decodeTypeAndValue(struct ndn_BinaryXmlDecoder *self, unsigned int *type, unsigned int *valueOut) 
 {
   unsigned int value = 0;
   int gotFirstOctet = 0;
@@ -69,29 +69,29 @@
       gotFirstOctet = 1;
     }
     
-		if (octet & ndn_BinaryXML_TT_FINAL) {
+		if (octet & ndn_BinaryXml_TT_FINAL) {
       // Finished.
-			*type = octet & ndn_BinaryXML_TT_MASK;
-			value = (value << ndn_BinaryXML_TT_VALUE_BITS) | ((octet >> ndn_BinaryXML_TT_BITS) & ndn_BinaryXML_TT_VALUE_MASK);
+			*type = octet & ndn_BinaryXml_TT_MASK;
+			value = (value << ndn_BinaryXml_TT_VALUE_BITS) | ((octet >> ndn_BinaryXml_TT_BITS) & ndn_BinaryXml_TT_VALUE_MASK);
       break;
 		}
 		
-    value = (value << ndn_BinaryXML_REGULAR_VALUE_BITS) | (octet & ndn_BinaryXML_REGULAR_VALUE_MASK);		
+    value = (value << ndn_BinaryXml_REGULAR_VALUE_BITS) | (octet & ndn_BinaryXml_REGULAR_VALUE_MASK);		
 	}
 
 	*valueOut = value;
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLDecoder_readElementStartDTag(struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag)
+ndn_Error ndn_BinaryXmlDecoder_readElementStartDTag(struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag)
 {
   ndn_Error error;
   unsigned int type;
   unsigned int value;
-  if (error = ndn_BinaryXMLDecoder_decodeTypeAndValue(self, &type, &value))
+  if (error = ndn_BinaryXmlDecoder_decodeTypeAndValue(self, &type, &value))
     return error;
   
-  if (type != ndn_BinaryXML_DTAG)
+  if (type != ndn_BinaryXml_DTAG)
     return NDN_ERROR_header_type_is_not_a_DTAG;
   
   if (value != expectedTag)
@@ -100,18 +100,18 @@
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLDecoder_readElementClose(struct ndn_BinaryXMLDecoder *self)
+ndn_Error ndn_BinaryXmlDecoder_readElementClose(struct ndn_BinaryXmlDecoder *self)
 {
   if (self->offset >= self->inputLength)
     return NDN_ERROR_read_past_the_end_of_the_input;
   
-  if (unsafeReadOctet(self) != ndn_BinaryXML_CLOSE)
+  if (unsafeReadOctet(self) != ndn_BinaryXml_CLOSE)
     return NDN_ERROR_did_not_get_the_expected_element_close;
   
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLDecoder_peekDTag(struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int *gotExpectedTag)
+ndn_Error ndn_BinaryXmlDecoder_peekDTag(struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int *gotExpectedTag)
 {
   // Default to 0.
   *gotExpectedTag = 0;
@@ -125,31 +125,31 @@
   unsigned int type;
   unsigned int value;
   unsigned int saveOffset = self->offset;
-  ndn_Error error = ndn_BinaryXMLDecoder_decodeTypeAndValue(self, &type, &value);
+  ndn_Error error = ndn_BinaryXmlDecoder_decodeTypeAndValue(self, &type, &value);
   // Restore offset.
   self->offset = saveOffset;
   
   if (error)
     return error;
   
-  if (type == ndn_BinaryXML_DTAG && value == expectedTag)
+  if (type == ndn_BinaryXml_DTAG && value == expectedTag)
     *gotExpectedTag = 1;
   
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLDecoder_readBinaryDTagElement
-  (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength)
+ndn_Error ndn_BinaryXmlDecoder_readBinaryDTagElement
+  (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLDecoder_readElementStartDTag(self, expectedTag))
+  if (error = ndn_BinaryXmlDecoder_readElementStartDTag(self, expectedTag))
     return error;
   
   if (allowNull) {
     if (self->offset >= self->inputLength)
       return NDN_ERROR_read_past_the_end_of_the_input;
   
-    if (unsafeGetOctet(self) == ndn_BinaryXML_CLOSE) {
+    if (unsafeGetOctet(self) == ndn_BinaryXml_CLOSE) {
       // The binary item is missing, and this is allowed, so read the element close and return a null value.
       ++self->offset;
       *value = 0;
@@ -159,27 +159,27 @@
   }
   
   unsigned int itemType;
-  if (error = ndn_BinaryXMLDecoder_decodeTypeAndValue(self, &itemType, valueLength))
+  if (error = ndn_BinaryXmlDecoder_decodeTypeAndValue(self, &itemType, valueLength))
     return error;
   // Ignore itemType.
   *value = self->input + self->offset;
   self->offset += *valueLength;
   
-  if (error = ndn_BinaryXMLDecoder_readElementClose(self))
+  if (error = ndn_BinaryXmlDecoder_readElementClose(self))
     return error;
   
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLDecoder_readOptionalBinaryDTagElement
-  (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength)
+ndn_Error ndn_BinaryXmlDecoder_readOptionalBinaryDTagElement
+  (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength)
 {
   ndn_Error error;
   int gotExpectedTag;
-  if (error = ndn_BinaryXMLDecoder_peekDTag(self, expectedTag, &gotExpectedTag))
+  if (error = ndn_BinaryXmlDecoder_peekDTag(self, expectedTag, &gotExpectedTag))
     return error;
   if (gotExpectedTag) {
-    if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement(self, expectedTag, allowNull, value, valueLength))
+    if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement(self, expectedTag, allowNull, value, valueLength))
       return error;
   }
   else {
@@ -190,34 +190,34 @@
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLDecoder_readUDataDTagElement
-  (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, unsigned char **value, unsigned int *valueLength)
+ndn_Error ndn_BinaryXmlDecoder_readUDataDTagElement
+  (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, unsigned char **value, unsigned int *valueLength)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLDecoder_readElementStartDTag(self, expectedTag))
+  if (error = ndn_BinaryXmlDecoder_readElementStartDTag(self, expectedTag))
     return error;
     
   unsigned int itemType;
-  if (error = ndn_BinaryXMLDecoder_decodeTypeAndValue(self, &itemType, valueLength))
+  if (error = ndn_BinaryXmlDecoder_decodeTypeAndValue(self, &itemType, valueLength))
     return error;
-  if (itemType != ndn_BinaryXML_UDATA)
+  if (itemType != ndn_BinaryXml_UDATA)
     return NDN_ERROR_item_is_not_UDATA;
   *value = self->input + self->offset;
   self->offset += *valueLength;
   
-  if (error = ndn_BinaryXMLDecoder_readElementClose(self))
+  if (error = ndn_BinaryXmlDecoder_readElementClose(self))
     return error;
   
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLDecoder_readUnsignedIntegerDTagElement
-  (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, unsigned int *value)
+ndn_Error ndn_BinaryXmlDecoder_readUnsignedIntegerDTagElement
+  (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, unsigned int *value)
 {
   unsigned char *udataValue;
   unsigned int udataValueLength;
   ndn_Error error;
-  if (error = ndn_BinaryXMLDecoder_readUDataDTagElement(self, expectedTag, &udataValue, &udataValueLength))
+  if (error = ndn_BinaryXmlDecoder_readUDataDTagElement(self, expectedTag, &udataValue, &udataValueLength))
     return error;
   
   if (error = parseUnsignedDecimalInt(udataValue, udataValueLength, value))
@@ -226,12 +226,12 @@
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement
-  (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int *value)
+ndn_Error ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+  (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int *value)
 {
   int gotExpectedTag;
   ndn_Error error;
-  if (error = ndn_BinaryXMLDecoder_peekDTag(self, expectedTag, &gotExpectedTag))
+  if (error = ndn_BinaryXmlDecoder_peekDTag(self, expectedTag, &gotExpectedTag))
     return error;
     
   if (!gotExpectedTag) {
@@ -240,32 +240,32 @@
   }
 
   unsigned int unsignedValue;
-  if (error = ndn_BinaryXMLDecoder_readUnsignedIntegerDTagElement(self, expectedTag, &unsignedValue))
+  if (error = ndn_BinaryXmlDecoder_readUnsignedIntegerDTagElement(self, expectedTag, &unsignedValue))
     return error;
   
   *value = (int)unsignedValue;
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLDecoder_readTimeMillisecondsDTagElement
-  (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, double *milliseconds)
+ndn_Error ndn_BinaryXmlDecoder_readTimeMillisecondsDTagElement
+  (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, double *milliseconds)
 {
   ndn_Error error;
   unsigned char *bytes;
   unsigned int bytesLength;
-  if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement(self, expectedTag, 0, &bytes, &bytesLength))
+  if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement(self, expectedTag, 0, &bytes, &bytesLength))
     return error;
     
-  *milliseconds = 1000.0 * ndn_BinaryXMLDecoder_unsignedBigEndianToDouble(bytes, bytesLength) / 4096.0;
+  *milliseconds = 1000.0 * ndn_BinaryXmlDecoder_unsignedBigEndianToDouble(bytes, bytesLength) / 4096.0;
   return 0;  
 }
 
-ndn_Error ndn_BinaryXMLDecoder_readOptionalTimeMillisecondsDTagElement
-  (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, double *milliseconds)
+ndn_Error ndn_BinaryXmlDecoder_readOptionalTimeMillisecondsDTagElement
+  (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, double *milliseconds)
 {
   int gotExpectedTag;
   ndn_Error error;
-  if (error = ndn_BinaryXMLDecoder_peekDTag(self, expectedTag, &gotExpectedTag))
+  if (error = ndn_BinaryXmlDecoder_peekDTag(self, expectedTag, &gotExpectedTag))
     return error;
     
   if (!gotExpectedTag) {
@@ -273,13 +273,13 @@
     return 0;
   }
 
-  if (error = ndn_BinaryXMLDecoder_readTimeMillisecondsDTagElement(self, expectedTag, milliseconds))
+  if (error = ndn_BinaryXmlDecoder_readTimeMillisecondsDTagElement(self, expectedTag, milliseconds))
     return error;
   
   return 0;
 }
 
-double ndn_BinaryXMLDecoder_unsignedBigEndianToDouble(unsigned char *bytes, unsigned int bytesLength) 
+double ndn_BinaryXmlDecoder_unsignedBigEndianToDouble(unsigned char *bytes, unsigned int bytesLength) 
 {
   double result = 0.0;
   unsigned int i;
diff --git a/ndn-cpp/c/encoding/BinaryXMLDecoder.h b/ndn-cpp/c/encoding/BinaryXMLDecoder.h
index 130eef4..87e1b7a 100644
--- a/ndn-cpp/c/encoding/BinaryXMLDecoder.h
+++ b/ndn-cpp/c/encoding/BinaryXMLDecoder.h
@@ -12,13 +12,13 @@
 extern "C" {
 #endif
 
-struct ndn_BinaryXMLDecoder {
+struct ndn_BinaryXmlDecoder {
   unsigned char *input;
   unsigned int inputLength;
   unsigned int offset;
 };
 
-static inline void ndn_BinaryXMLDecoder_init(struct ndn_BinaryXMLDecoder *self, unsigned char *input, unsigned int inputLength) 
+static inline void ndn_BinaryXmlDecoder_init(struct ndn_BinaryXmlDecoder *self, unsigned char *input, unsigned int inputLength) 
 {
   self->input = input;
   self->inputLength = inputLength;
@@ -27,45 +27,45 @@
 
 /**
  * Decode the header's type and value from self's input starting at offset. Update offset.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
  * @param type output for the header type
  * @param value output for the header value
  * @return 0 for success, else an error code for read past the end of the input or if the initial byte is zero
  */
-ndn_Error ndn_BinaryXMLDecoder_decodeTypeAndValue(struct ndn_BinaryXMLDecoder *self, unsigned int *type, unsigned int *value);
+ndn_Error ndn_BinaryXmlDecoder_decodeTypeAndValue(struct ndn_BinaryXmlDecoder *self, unsigned int *type, unsigned int *value);
 
 /**
  * Decode the header from self's input starting at offset, expecting the type to be DTAG and the value to be expectedTag.
  * Update offset.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
  * @param expectedTag the expected value for DTAG
  * @return 0 for success, else an error code, including an error if not the expected tag
  */
-ndn_Error ndn_BinaryXMLDecoder_readElementStartDTag(struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag);
+ndn_Error ndn_BinaryXmlDecoder_readElementStartDTag(struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag);
 
 /**
  * Read one byte from self's input starting at offset, expecting it to be the element close.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
  * @return 0 for success, else an error code, including an error if not the element close
  */
-ndn_Error ndn_BinaryXMLDecoder_readElementClose(struct ndn_BinaryXMLDecoder *self);
+ndn_Error ndn_BinaryXmlDecoder_readElementClose(struct ndn_BinaryXmlDecoder *self);
 
 /**
  * Decode the header from self's input starting at offset, and if it is a DTAG where the value is the expectedTag,
  * then set gotExpectedTag to 1, else 0.  Do not update offset, including if returning an error.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
  * @param expectedTag the expected value for DTAG
  * @param gotExpectedTag output a 1 if got the expected tag, else 0
  * @return 0 for success, else an error code for read past the end of the input
  */
-ndn_Error ndn_BinaryXMLDecoder_peekDTag(struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int *gotExpectedTag);
+ndn_Error ndn_BinaryXmlDecoder_peekDTag(struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int *gotExpectedTag);
 
 /**
  * Decode the header from self's input starting at offset, expecting the type to be DTAG and the value to be expectedTag.
  * Then read one item of any type (presumably BLOB, UDATA, TAG or ATTR) and return the item's value and length.
  * However, if allowNull is 1, then the item may be absent.
  * Finally, read the element close.  Update offset.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
  * @param expectedTag the expected value for DTAG
  * @param allowNull 1 if the binary item may be missing
  * @param value output a pointer to the binary data inside self's input buffer. However, if allowNull is 1 and the
@@ -75,13 +75,13 @@
  * @return 0 for success, else an error code, including an error if not the expected tag, or if allowNull is 0
  * and the binary data is absent
  */
-ndn_Error ndn_BinaryXMLDecoder_readBinaryDTagElement
-  (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength);
+ndn_Error ndn_BinaryXmlDecoder_readBinaryDTagElement
+  (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength);
 
 /**
- * Peek at the next element and if it is the expectedTag, call ndn_BinaryXMLDecoder_readBinaryDTagElement.
+ * Peek at the next element and if it is the expectedTag, call ndn_BinaryXmlDecoder_readBinaryDTagElement.
  * Otherwise, set value and valueLength to 0.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
  * @param expectedTag the expected value for DTAG
  * @param allowNull 1 if the binary item may be missing
  * @param value output a pointer to the binary data inside self's input buffer. However, if allowNull is 1 and the
@@ -90,69 +90,69 @@
  * binary data item is absent, then return 0.
  * @return 0 for success, else an error code, including if allowNull is 0 and the binary data is absent
  */
-ndn_Error ndn_BinaryXMLDecoder_readOptionalBinaryDTagElement
-  (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength);
+ndn_Error ndn_BinaryXmlDecoder_readOptionalBinaryDTagElement
+  (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength);
 
 /**
  * Decode the header from self's input starting at offset, expecting the type to be DTAG and the value to be expectedTag.
  * Then read one item expecting it to be type UDATA, and return the item's value and length.
  * Finally, read the element close.  Update offset.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
  * @param expectedTag the expected value for DTAG
  * @param value output a pointer to the binary data inside self's input buffer.
  * @param valueLength output the length of the binary data.
  * @return 0 for success, else an error code, including an error if not the expected tag, or if the item is not UDATA.
  */
-ndn_Error ndn_BinaryXMLDecoder_readUDataDTagElement
-  (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, unsigned char **value, unsigned int *valueLength);
+ndn_Error ndn_BinaryXmlDecoder_readUDataDTagElement
+  (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, unsigned char **value, unsigned int *valueLength);
 
 /**
  * Decode the header from self's input starting at offset, expecting the type to be DTAG and the value to be expectedTag.
  * Then read one item expecting it to be type UDATA, parse it as an unsigned decimal integer and return the integer.
  * Finally, read the element close.  Update offset.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
  * @param expectedTag the expected value for DTAG
  * @param value output the unsigned integer
  * @return 0 for success, else an error code, including an error if not the expected tag, or if the item is not UDATA,
  * or can't parse the integer
  */
-ndn_Error ndn_BinaryXMLDecoder_readUnsignedIntegerDTagElement
-  (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, unsigned int *value);
+ndn_Error ndn_BinaryXmlDecoder_readUnsignedIntegerDTagElement
+  (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, unsigned int *value);
 
 /**
- * Peek at the next element, and if it has the expectedTag then call ndn_BinaryXMLDecoder_readUnsignedIntegerDTagElement.
+ * Peek at the next element, and if it has the expectedTag then call ndn_BinaryXmlDecoder_readUnsignedIntegerDTagElement.
  * Otherwise, set value to -1.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
  * @param expectedTag the expected value for DTAG
  * @param value output the unsigned integer cast to int, or -1 if the next element doesn't have expectedTag.
  * @return 0 for success, else an error code, including an error if the item is not UDATA,
  * or can't parse the integer
  */
-ndn_Error ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement
-  (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int *value);
+ndn_Error ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+  (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int *value);
 
 /**
  * Decode the header from self's input starting at offset, expecting the type to be DTAG and the value to be expectedTag.
  * Then read one item, parse it as an unsigned big endian integer in 4096 ticks per second, and convert it to milliseconds.
  * Finally, read the element close.  Update offset.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
  * @param expectedTag the expected value for DTAG
  * @param milliseconds output the number of milliseconds
  * @return 0 for success, else an error code, including an error if not the expected tag
  */
-ndn_Error ndn_BinaryXMLDecoder_readTimeMillisecondsDTagElement
-  (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, double *milliseconds);
+ndn_Error ndn_BinaryXmlDecoder_readTimeMillisecondsDTagElement
+  (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, double *milliseconds);
 
 /**
- * Peek at the next element, and if it has the expectedTag then call ndn_BinaryXMLDecoder_readTimeMillisecondsDTagElement.
+ * Peek at the next element, and if it has the expectedTag then call ndn_BinaryXmlDecoder_readTimeMillisecondsDTagElement.
  * Otherwise, set value to -1.0 .
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
  * @param expectedTag the expected value for DTAG
  * @param milliseconds output the number of milliseconds, or -1.0 if the next element doesn't have expectedTag.
  * @return 0 for success, else an error code
  */
-ndn_Error ndn_BinaryXMLDecoder_readOptionalTimeMillisecondsDTagElement
-  (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, double *milliseconds);
+ndn_Error ndn_BinaryXmlDecoder_readOptionalTimeMillisecondsDTagElement
+  (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, double *milliseconds);
 
 /**
  * Interpret the bytes as an unsigned big endian integer and convert to a double. Don't check for overflow.
@@ -161,14 +161,14 @@
  * @param bytesLength the length of bytes
  * @return the result
  */
-double ndn_BinaryXMLDecoder_unsignedBigEndianToDouble(unsigned char *bytes, unsigned int bytesLength); 
+double ndn_BinaryXmlDecoder_unsignedBigEndianToDouble(unsigned char *bytes, unsigned int bytesLength); 
 
 /**
  * Set the offset into the input, used for the next read.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
  * @param offset the new offset
  */
-static inline void ndn_BinaryXMLDecoder_seek(struct ndn_BinaryXMLDecoder *self, unsigned int offset) 
+static inline void ndn_BinaryXmlDecoder_seek(struct ndn_BinaryXmlDecoder *self, unsigned int offset) 
 {
   self->offset = offset;
 }
diff --git a/ndn-cpp/c/encoding/BinaryXMLElementReader.c b/ndn-cpp/c/encoding/BinaryXMLElementReader.c
index 169db20..556c376 100644
--- a/ndn-cpp/c/encoding/BinaryXMLElementReader.c
+++ b/ndn-cpp/c/encoding/BinaryXMLElementReader.c
@@ -5,16 +5,16 @@
 
 #include "BinaryXMLElementReader.h"
 
-ndn_Error ndn_BinaryXMLElementReader_onReceivedData
-  (struct ndn_BinaryXMLElementReader *self, unsigned char *data, unsigned int dataLength)
+ndn_Error ndn_BinaryXmlElementReader_onReceivedData
+  (struct ndn_BinaryXmlElementReader *self, unsigned char *data, unsigned int dataLength)
 {
   // Process multiple objects in the data.
   while(1) {
     // Scan the input to check if a whole binary XML object has been read.
-    ndn_BinaryXMLStructureDecoder_seek(&self->structureDecoder, 0);
+    ndn_BinaryXmlStructureDecoder_seek(&self->structureDecoder, 0);
     
     ndn_Error error;
-    if (error = ndn_BinaryXMLStructureDecoder_findElementEnd(&self->structureDecoder, data, dataLength))
+    if (error = ndn_BinaryXmlStructureDecoder_findElementEnd(&self->structureDecoder, data, dataLength))
       return error;
     if (self->structureDecoder.gotElementEnd) {
       // Got the remainder of an element.  Report to the caller.
@@ -39,7 +39,7 @@
       // Need to read a new object.
       data += self->structureDecoder.offset;
       dataLength -= self->structureDecoder.offset;
-      ndn_BinaryXMLStructureDecoder_init(&self->structureDecoder);
+      ndn_BinaryXmlStructureDecoder_init(&self->structureDecoder);
       if (dataLength == 0)
         // No more data in the packet.
         return 0;
diff --git a/ndn-cpp/c/encoding/BinaryXMLElementReader.h b/ndn-cpp/c/encoding/BinaryXMLElementReader.h
index 9a80deb..f4501ad 100644
--- a/ndn-cpp/c/encoding/BinaryXMLElementReader.h
+++ b/ndn-cpp/c/encoding/BinaryXMLElementReader.h
@@ -25,7 +25,7 @@
  * Initialize an ndn_ElementListener struct to use the onReceivedElement function pointer.
  * @param self pointer to the ndn_ElementListener struct
  * @param onReceivedElement pointer to a function which is called when an entire binary XML element is received.
- * self is the pointer to this ndn_ElementListener struct.  See ndn_BinaryXMLElementReader_onReceivedData.
+ * self is the pointer to this ndn_ElementListener struct.  See ndn_BinaryXmlElementReader_onReceivedData.
  */
 static inline void ndn_ElementListener_init
   (struct ndn_ElementListener *self, void (*onReceivedElement)(struct ndn_ElementListener *self, unsigned char *element, unsigned int elementLength))
@@ -34,33 +34,33 @@
 }
   
 /**
- * A BinaryXmlElementReader lets you call ndn_BinaryXMLElementReader_onReceivedData multiple times which uses an
- * ndn_BinaryXMLStructureDecoder to detect the end of a binary XML element and calls
+ * A BinaryXmlElementReader lets you call ndn_BinaryXmlElementReader_onReceivedData multiple times which uses an
+ * ndn_BinaryXmlStructureDecoder to detect the end of a binary XML element and calls
  * (*elementListener->onReceivedElement)(element, elementLength) with the element. 
  * This handles the case where a single call to onReceivedData may contain multiple elements.
  */
-struct ndn_BinaryXMLElementReader {
+struct ndn_BinaryXmlElementReader {
   struct ndn_ElementListener *elementListener;
-  struct ndn_BinaryXMLStructureDecoder structureDecoder;
+  struct ndn_BinaryXmlStructureDecoder structureDecoder;
   int usePartialData;
   struct ndn_DynamicUCharArray partialData;
   unsigned int partialDataLength;
 };
 
 /**
- * Initialize an ndn_BinaryXMLElementReader struct with the elementListener and a buffer for saving partial data.
- * @param self pointer to the ndn_BinaryXMLElementReader struct
- * @param elementListener pointer to the ndn_ElementListener used by ndn_BinaryXMLElementReader_onReceivedData.
+ * Initialize an ndn_BinaryXmlElementReader struct with the elementListener and a buffer for saving partial data.
+ * @param self pointer to the ndn_BinaryXmlElementReader struct
+ * @param elementListener pointer to the ndn_ElementListener used by ndn_BinaryXmlElementReader_onReceivedData.
  * @param buffer the allocated buffer.  If reallocFunction is null, this should be large enough to save a full element, perhaps 8000 bytes.
  * @param bufferLength the length of the buffer
  * @param reallocFunction see ndn_DynamicUCharArray_ensureLength.  This may be 0.
  */
-static inline void ndn_BinaryXMLElementReader_init
-  (struct ndn_BinaryXMLElementReader *self, struct ndn_ElementListener *elementListener,
+static inline void ndn_BinaryXmlElementReader_init
+  (struct ndn_BinaryXmlElementReader *self, struct ndn_ElementListener *elementListener,
    unsigned char *buffer, unsigned int bufferLength, unsigned char * (*reallocFunction)(unsigned char *, unsigned int))
 {
   self->elementListener = elementListener;
-  ndn_BinaryXMLStructureDecoder_init(&self->structureDecoder);
+  ndn_BinaryXmlStructureDecoder_init(&self->structureDecoder);
   self->usePartialData = 0;
   ndn_DynamicUCharArray_init(&self->partialData, buffer, bufferLength, reallocFunction);
 }
@@ -68,13 +68,13 @@
 /**
  * Continue to read binary XML data until the end of an element, then call (*elementListener->onReceivedElement)(element, elementLength).
  * The buffer passed to onReceivedElement is only valid during this call.  If you need the data later, you must copy.
- * @param self pointer to the ndn_BinaryXMLElementReader struct
+ * @param self pointer to the ndn_BinaryXmlElementReader struct
  * @param data pointer to the buffer with the binary XML bytes
  * @param dataLength length of data
  * @return 0 for success, else an error code
  */
-ndn_Error ndn_BinaryXMLElementReader_onReceivedData
-  (struct ndn_BinaryXMLElementReader *self, unsigned char *data, unsigned int dataLength);
+ndn_Error ndn_BinaryXmlElementReader_onReceivedData
+  (struct ndn_BinaryXmlElementReader *self, unsigned char *data, unsigned int dataLength);
 
 #ifdef	__cplusplus
 }
diff --git a/ndn-cpp/c/encoding/BinaryXMLEncoder.c b/ndn-cpp/c/encoding/BinaryXMLEncoder.c
index b7f1db1..0b38f87 100644
--- a/ndn-cpp/c/encoding/BinaryXMLEncoder.c
+++ b/ndn-cpp/c/encoding/BinaryXMLEncoder.c
@@ -10,20 +10,20 @@
 #include "BinaryXMLEncoder.h"
 
 enum {
-  ENCODING_LIMIT_1_BYTE = ((1 << ndn_BinaryXML_TT_VALUE_BITS) - 1),
-  ENCODING_LIMIT_2_BYTES = ((1 << (ndn_BinaryXML_TT_VALUE_BITS + ndn_BinaryXML_REGULAR_VALUE_BITS)) - 1),
-  ENCODING_LIMIT_3_BYTES = ((1 << (ndn_BinaryXML_TT_VALUE_BITS + 2 * ndn_BinaryXML_REGULAR_VALUE_BITS)) - 1)
+  ENCODING_LIMIT_1_BYTE = ((1 << ndn_BinaryXml_TT_VALUE_BITS) - 1),
+  ENCODING_LIMIT_2_BYTES = ((1 << (ndn_BinaryXml_TT_VALUE_BITS + ndn_BinaryXml_REGULAR_VALUE_BITS)) - 1),
+  ENCODING_LIMIT_3_BYTES = ((1 << (ndn_BinaryXml_TT_VALUE_BITS + 2 * ndn_BinaryXml_REGULAR_VALUE_BITS)) - 1)
 };
 
 /**
  * Call ndn_DynamicUCharArray_ensureLength to ensure that there is enough room in the output, and copy
  * array to the output.  This does not write a header.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
  * @param array the array to copy
  * @param arrayLength the length of the array
  * @return 0 for success, else an error code
  */
-static ndn_Error writeArray(struct ndn_BinaryXMLEncoder *self, unsigned char *array, unsigned int arrayLength)
+static ndn_Error writeArray(struct ndn_BinaryXmlEncoder *self, unsigned char *array, unsigned int arrayLength)
 {
   ndn_Error error;
   if (error = ndn_DynamicUCharArray_ensureLength(&self->output, self->offset + arrayLength))
@@ -52,10 +52,10 @@
 	
 	// Last byte gives you TT_VALUE_BITS.
 	// Remainder each gives you REGULAR_VALUE_BITS.
-	x >>= ndn_BinaryXML_TT_VALUE_BITS;
+	x >>= ndn_BinaryXml_TT_VALUE_BITS;
 	while (x != 0) {
     ++nBytes;
-	  x >>= ndn_BinaryXML_REGULAR_VALUE_BITS;
+	  x >>= ndn_BinaryXml_REGULAR_VALUE_BITS;
 	}
   
 	return nBytes;
@@ -88,11 +88,11 @@
  * Write x as an unsigned decimal integer to the output with the digits in reverse order, using ndn_DynamicUCharArray_ensureLength.
  * This does not write a header.
  * We encode in reverse order, because this is the natural way to encode the digits, and the caller can reverse as needed.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
  * @param x the unsigned int to write
  * @return 0 for success, else an error code
  */
-static ndn_Error encodeReversedUnsignedDecimalInt(struct ndn_BinaryXMLEncoder *self, unsigned int x) 
+static ndn_Error encodeReversedUnsignedDecimalInt(struct ndn_BinaryXmlEncoder *self, unsigned int x) 
 {
   while (1) {
     ndn_Error error;
@@ -114,13 +114,13 @@
  * then encode the header at startOffset.
  * startOffser it the position in self-output.array of the first byte of the buffer and self->offset is the first byte past the end.
  * We reverse and shift in the same function to avoid unnecessary copying if we first reverse then shift.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
  * @param startOffset the offset in self->output.array of the start of the buffer to shift right
  * @param type the header type
  * @return 0 for success, else an error code
  */
 static ndn_Error reverseBufferAndInsertHeader
-  (struct ndn_BinaryXMLEncoder *self, unsigned int startOffset, unsigned int type)
+  (struct ndn_BinaryXmlEncoder *self, unsigned int startOffset, unsigned int type)
 {
   unsigned int nBufferBytes = self->offset - startOffset;
   unsigned int nHeaderBytes = getNHeaderEncodingBytes(nBufferBytes);
@@ -141,7 +141,7 @@
   
   // Override the offset to force encodeTypeAndValue to encode at startOffset, then fix the offset.
   self->offset = startOffset;
-  if (error = ndn_BinaryXMLEncoder_encodeTypeAndValue(self, ndn_BinaryXML_UDATA, nBufferBytes))
+  if (error = ndn_BinaryXmlEncoder_encodeTypeAndValue(self, ndn_BinaryXml_UDATA, nBufferBytes))
     // We don't really expect to get an error, since we have already ensured the length.
     return error;
   self->offset = startOffset + nHeaderBytes + nBufferBytes;
@@ -170,9 +170,9 @@
   *hi32 = (unsigned long)((x - lo32Double) / twoPower32);
 }
 
-ndn_Error ndn_BinaryXMLEncoder_encodeTypeAndValue(struct ndn_BinaryXMLEncoder *self, unsigned int type, unsigned int value)
+ndn_Error ndn_BinaryXmlEncoder_encodeTypeAndValue(struct ndn_BinaryXmlEncoder *self, unsigned int type, unsigned int value)
 {
-	if (type > ndn_BinaryXML_UDATA)
+	if (type > ndn_BinaryXml_UDATA)
 		return NDN_ERROR_header_type_is_out_of_range;
   
 	// Encode backwards. Calculate how many bytes we need.
@@ -183,16 +183,16 @@
 
 	// Bottom 4 bits of value go in last byte with tag.
 	self->output.array[self->offset + nEncodingBytes - 1] = 
-		(ndn_BinaryXML_TT_MASK & type | 
-		((ndn_BinaryXML_TT_VALUE_MASK & value) << ndn_BinaryXML_TT_BITS)) |
-		ndn_BinaryXML_TT_FINAL; // set top bit for last byte
-	value >>= ndn_BinaryXML_TT_VALUE_BITS;
+		(ndn_BinaryXml_TT_MASK & type | 
+		((ndn_BinaryXml_TT_VALUE_MASK & value) << ndn_BinaryXml_TT_BITS)) |
+		ndn_BinaryXml_TT_FINAL; // set top bit for last byte
+	value >>= ndn_BinaryXml_TT_VALUE_BITS;
 	
 	// Rest of value goes into preceding bytes, 7 bits per byte. (Zero top bit is "more" flag.)
 	unsigned int i = self->offset + nEncodingBytes - 2;
 	while (value != 0 && i >= self->offset) {
-		self->output.array[i] = (value & ndn_BinaryXML_REGULAR_VALUE_MASK);
-		value >>= ndn_BinaryXML_REGULAR_VALUE_BITS;
+		self->output.array[i] = (value & ndn_BinaryXml_REGULAR_VALUE_MASK);
+		value >>= ndn_BinaryXml_REGULAR_VALUE_BITS;
 		--i;
 	}
 	if (value != 0)
@@ -204,22 +204,22 @@
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLEncoder_writeElementClose(struct ndn_BinaryXMLEncoder *self)
+ndn_Error ndn_BinaryXmlEncoder_writeElementClose(struct ndn_BinaryXmlEncoder *self)
 {
   ndn_Error error;
   if (error = ndn_DynamicUCharArray_ensureLength(&self->output, self->offset + 1))
     return error;
   
-	self->output.array[self->offset] = ndn_BinaryXML_CLOSE;
+	self->output.array[self->offset] = ndn_BinaryXml_CLOSE;
 	self->offset += 1;
   
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLEncoder_writeBlob(struct ndn_BinaryXMLEncoder *self, unsigned char *value, unsigned int valueLength)
+ndn_Error ndn_BinaryXmlEncoder_writeBlob(struct ndn_BinaryXmlEncoder *self, unsigned char *value, unsigned int valueLength)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLEncoder_encodeTypeAndValue(self, ndn_BinaryXML_BLOB, valueLength))
+  if (error = ndn_BinaryXmlEncoder_encodeTypeAndValue(self, ndn_BinaryXml_BLOB, valueLength))
     return error;
   
   if (error = writeArray(self, value, valueLength))
@@ -228,22 +228,22 @@
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLEncoder_writeBlobDTagElement(struct ndn_BinaryXMLEncoder *self, unsigned int tag, unsigned char *value, unsigned int valueLength)
+ndn_Error ndn_BinaryXmlEncoder_writeBlobDTagElement(struct ndn_BinaryXmlEncoder *self, unsigned int tag, unsigned char *value, unsigned int valueLength)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(self, tag))
+  if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(self, tag))
     return error;
   
-  if (error = ndn_BinaryXMLEncoder_writeBlob(self, value, valueLength))
+  if (error = ndn_BinaryXmlEncoder_writeBlob(self, value, valueLength))
     return error;  
   
-  if (error = ndn_BinaryXMLEncoder_writeElementClose(self))
+  if (error = ndn_BinaryXmlEncoder_writeElementClose(self))
     return error;
   
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLEncoder_writeUnsignedDecimalInt(struct ndn_BinaryXMLEncoder *self, unsigned int value)
+ndn_Error ndn_BinaryXmlEncoder_writeUnsignedDecimalInt(struct ndn_BinaryXmlEncoder *self, unsigned int value)
 {
   // First write the decimal int (to find out how many bytes it is), then shift it forward to make room for the header.
   unsigned int startOffset = self->offset;
@@ -252,28 +252,28 @@
   if (error = encodeReversedUnsignedDecimalInt(self, value))
     return error;
   
-  if (error = reverseBufferAndInsertHeader(self, startOffset, ndn_BinaryXML_UDATA))
+  if (error = reverseBufferAndInsertHeader(self, startOffset, ndn_BinaryXml_UDATA))
     return error;
   
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLEncoder_writeUnsignedDecimalIntDTagElement(struct ndn_BinaryXMLEncoder *self, unsigned int tag, unsigned int value)
+ndn_Error ndn_BinaryXmlEncoder_writeUnsignedDecimalIntDTagElement(struct ndn_BinaryXmlEncoder *self, unsigned int tag, unsigned int value)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(self, tag))
+  if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(self, tag))
     return error;
   
-  if (error = ndn_BinaryXMLEncoder_writeUnsignedDecimalInt(self, value))
+  if (error = ndn_BinaryXmlEncoder_writeUnsignedDecimalInt(self, value))
     return error;  
   
-  if (error = ndn_BinaryXMLEncoder_writeElementClose(self))
+  if (error = ndn_BinaryXmlEncoder_writeElementClose(self))
     return error;
   
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLEncoder_writeAbsDoubleBigEndianBlob(struct ndn_BinaryXMLEncoder *self, double value)
+ndn_Error ndn_BinaryXmlEncoder_writeAbsDoubleBigEndianBlob(struct ndn_BinaryXmlEncoder *self, double value)
 {
   unsigned long hi32, lo32;
   splitAbsDouble(value, &hi32, &lo32);
@@ -309,22 +309,22 @@
     }
   }
   
-  if (error = reverseBufferAndInsertHeader(self, startOffset, ndn_BinaryXML_BLOB))
+  if (error = reverseBufferAndInsertHeader(self, startOffset, ndn_BinaryXml_BLOB))
     return error;
   
   return 0;
 }
 
-ndn_Error ndn_BinaryXMLEncoder_writeTimeMillisecondsDTagElement(struct ndn_BinaryXMLEncoder *self, unsigned int tag, double milliseconds)
+ndn_Error ndn_BinaryXmlEncoder_writeTimeMillisecondsDTagElement(struct ndn_BinaryXmlEncoder *self, unsigned int tag, double milliseconds)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(self, tag))
+  if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(self, tag))
     return error;
    
-  if (error = ndn_BinaryXMLEncoder_writeAbsDoubleBigEndianBlob(self, (milliseconds / 1000.0) * 4096.0))
+  if (error = ndn_BinaryXmlEncoder_writeAbsDoubleBigEndianBlob(self, (milliseconds / 1000.0) * 4096.0))
     return error;
     
-  if (error = ndn_BinaryXMLEncoder_writeElementClose(self))
+  if (error = ndn_BinaryXmlEncoder_writeElementClose(self))
     return error;
   
   return 0;
diff --git a/ndn-cpp/c/encoding/BinaryXMLEncoder.h b/ndn-cpp/c/encoding/BinaryXMLEncoder.h
index ac20ae8..c300d17 100644
--- a/ndn-cpp/c/encoding/BinaryXMLEncoder.h
+++ b/ndn-cpp/c/encoding/BinaryXMLEncoder.h
@@ -14,24 +14,24 @@
 extern "C" {
 #endif
 
-/** An ndn_BinaryXMLEncoder struct is used by all the encoding functions.  You should initialize it with
- *  ndn_BinaryXMLEncoder_init.
+/** An ndn_BinaryXmlEncoder struct is used by all the encoding functions.  You should initialize it with
+ *  ndn_BinaryXmlEncoder_init.
  */
-struct ndn_BinaryXMLEncoder {
+struct ndn_BinaryXmlEncoder {
   struct ndn_DynamicUCharArray output; /**< receives the encoded output */
   unsigned int offset;             /**< the offset into output.array for the next encoding */
 };
 
 /**
- * Initialize an ndn_BinaryXMLEncoder_init struct with the arguments for initializing the ndn_DynamicUCharArray.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * Initialize an ndn_BinaryXmlEncoder_init struct with the arguments for initializing the ndn_DynamicUCharArray.
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
  * @param outputArray the allocated array buffer to receive the encoding
  * @param outputArrayLength the length of outputArray
  * @param reallocFunction the realloc function used by ndn_DynamicUCharArray_ensureLength.  If outputArrayLength
  * is large enough to receive the entire encoding, this can be 0.
  */
-static inline void ndn_BinaryXMLEncoder_init
-  (struct ndn_BinaryXMLEncoder *self, unsigned char *outputArray, unsigned int outputArrayLength, 
+static inline void ndn_BinaryXmlEncoder_init
+  (struct ndn_BinaryXmlEncoder *self, unsigned char *outputArray, unsigned int outputArrayLength, 
    unsigned char * (*reallocFunction)(unsigned char *, unsigned int)) 
 {
   ndn_DynamicUCharArray_init(&self->output, outputArray, outputArrayLength, reallocFunction);
@@ -40,134 +40,134 @@
 
 /**
  * Encode a header with the type and value and write it to self->output.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
  * @param type the header type
  * @param value the header value
  * @return 0 for success, else an error code
  */
-ndn_Error ndn_BinaryXMLEncoder_encodeTypeAndValue(struct ndn_BinaryXMLEncoder *self, unsigned int type, unsigned int value);
+ndn_Error ndn_BinaryXmlEncoder_encodeTypeAndValue(struct ndn_BinaryXmlEncoder *self, unsigned int type, unsigned int value);
 
 /**
  * Write an element start header using DTAG with the tag to self->output.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
  * @param tag the DTAG tag
  * @return 0 for success, else an error code
  */
-static inline ndn_Error ndn_BinaryXMLEncoder_writeElementStartDTag(struct ndn_BinaryXMLEncoder *self, unsigned int tag) 
+static inline ndn_Error ndn_BinaryXmlEncoder_writeElementStartDTag(struct ndn_BinaryXmlEncoder *self, unsigned int tag) 
 {
-  return ndn_BinaryXMLEncoder_encodeTypeAndValue(self, ndn_BinaryXML_DTAG, tag);
+  return ndn_BinaryXmlEncoder_encodeTypeAndValue(self, ndn_BinaryXml_DTAG, tag);
 }
 
 /**
  * Write an element close to self->output.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
  * @return 0 for success, else an error code
  */
-ndn_Error ndn_BinaryXMLEncoder_writeElementClose(struct ndn_BinaryXMLEncoder *self);
+ndn_Error ndn_BinaryXmlEncoder_writeElementClose(struct ndn_BinaryXmlEncoder *self);
 
 /**
  * Write a BLOB header, then the bytes of the blob value to self->output.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
  * @param value an array of bytes for the blob value
  * @param valueLength the length of the array
  * @return 0 for success, else an error code
  */
-ndn_Error ndn_BinaryXMLEncoder_writeBlob(struct ndn_BinaryXMLEncoder *self, unsigned char *value, unsigned int valueLength);
+ndn_Error ndn_BinaryXmlEncoder_writeBlob(struct ndn_BinaryXmlEncoder *self, unsigned char *value, unsigned int valueLength);
 
 /**
  * Write an element start header using DTAG with the tag to self->output, then the blob, then an element close.
- * (If you want to just write the blob, use ndn_BinaryXMLEncoder_writeBlob .)
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * (If you want to just write the blob, use ndn_BinaryXmlEncoder_writeBlob .)
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
  * @param tag the DTAG tag
  * @param value an array of bytes for the blob value
  * @param valueLength the length of the array
  * @return 0 for success, else an error code
  */
-ndn_Error ndn_BinaryXMLEncoder_writeBlobDTagElement(struct ndn_BinaryXMLEncoder *self, unsigned int tag, unsigned char *value, unsigned int valueLength);
+ndn_Error ndn_BinaryXmlEncoder_writeBlobDTagElement(struct ndn_BinaryXmlEncoder *self, unsigned int tag, unsigned char *value, unsigned int valueLength);
 
 /**
- * If value or valueLen is 0 then do nothing, otherwise call ndn_BinaryXMLEncoder_writeBlobDTagElement.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * If value or valueLen is 0 then do nothing, otherwise call ndn_BinaryXmlEncoder_writeBlobDTagElement.
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
  * @param tag the DTAG tag
  * @param value an array of bytes for the blob value
  * @param valueLength the length of the array
  * @return 0 for success, else an error code
  */
-static inline ndn_Error ndn_BinaryXMLEncoder_writeOptionalBlobDTagElement
-  (struct ndn_BinaryXMLEncoder *self, unsigned int tag, unsigned char *value, unsigned int valueLength)
+static inline ndn_Error ndn_BinaryXmlEncoder_writeOptionalBlobDTagElement
+  (struct ndn_BinaryXmlEncoder *self, unsigned int tag, unsigned char *value, unsigned int valueLength)
 {
   if (value && valueLength > 0)
-    return ndn_BinaryXMLEncoder_writeBlobDTagElement(self, tag, value, valueLength);
+    return ndn_BinaryXmlEncoder_writeBlobDTagElement(self, tag, value, valueLength);
   else
     return (ndn_Error)0;
 }
 
 /**
  * Write a UDATA header, then the value as an unsigned decimal integer.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
  * @param value the unsigned int
  * @return 0 for success, else an error code
  */
-ndn_Error ndn_BinaryXMLEncoder_writeUnsignedDecimalInt(struct ndn_BinaryXMLEncoder *self, unsigned int value);
+ndn_Error ndn_BinaryXmlEncoder_writeUnsignedDecimalInt(struct ndn_BinaryXmlEncoder *self, unsigned int value);
 
 /**
  * Write an element start header using DTAG with the tag to self->output, then the value as an unsigned decimal integer, 
  * then an element close.
- * (If you want to just write the integer, use ndn_BinaryXMLEncoder_writeUnsignedDecimalInt .)
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * (If you want to just write the integer, use ndn_BinaryXmlEncoder_writeUnsignedDecimalInt .)
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
  * @param tag the DTAG tag
  * @param value the unsigned int
  * @return 0 for success, else an error code
  */
-ndn_Error ndn_BinaryXMLEncoder_writeUnsignedDecimalIntDTagElement(struct ndn_BinaryXMLEncoder *self, unsigned int tag, unsigned int value);
+ndn_Error ndn_BinaryXmlEncoder_writeUnsignedDecimalIntDTagElement(struct ndn_BinaryXmlEncoder *self, unsigned int tag, unsigned int value);
 
 /**
- * If value is negative then do nothing, otherwise call ndn_BinaryXMLEncoder_writeUnsignedDecimalIntDTagElement.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * If value is negative then do nothing, otherwise call ndn_BinaryXmlEncoder_writeUnsignedDecimalIntDTagElement.
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
  * @param tag the DTAG tag
  * @param value negative for none, otherwise use (unsigned int)value
  * @return 0 for success, else an error code
  */
-static inline ndn_Error ndn_BinaryXMLEncoder_writeOptionalUnsignedDecimalIntDTagElement(struct ndn_BinaryXMLEncoder *self, unsigned int tag, int value)
+static inline ndn_Error ndn_BinaryXmlEncoder_writeOptionalUnsignedDecimalIntDTagElement(struct ndn_BinaryXmlEncoder *self, unsigned int tag, int value)
 {
   if (value >= 0)
-    return ndn_BinaryXMLEncoder_writeUnsignedDecimalIntDTagElement(self, tag, (unsigned int)value);
+    return ndn_BinaryXmlEncoder_writeUnsignedDecimalIntDTagElement(self, tag, (unsigned int)value);
   else
     return (ndn_Error)0;
 }
 
 /**
  * Write a BLOB header, then the absolute value of value to self->output encoded as big endian.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
  * @param value the double to encode as big endian.  If value is 0, the big endian encoding has zero bytes.
  * The value is converted to absolute value.
  * @return 0 for success, else an error code
  */
-ndn_Error ndn_BinaryXMLEncoder_writeAbsDoubleBigEndianBlob(struct ndn_BinaryXMLEncoder *self, double value);
+ndn_Error ndn_BinaryXmlEncoder_writeAbsDoubleBigEndianBlob(struct ndn_BinaryXmlEncoder *self, double value);
 
 /**
  * Write an element start header using DTAG with the tag to self->output, then the absolute value of milliseconds
  * as a big endian BLOB converted to 4096 ticks per second, then an element close.
- * (If you want to just write the integer, use ndn_BinaryXMLEncoder_writeUnsignedDecimalInt .)
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * (If you want to just write the integer, use ndn_BinaryXmlEncoder_writeUnsignedDecimalInt .)
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
  * @param tag the DTAG tag
  * @param milliseconds the the number of milliseconds
  * @return 0 for success, else an error code
  */
-ndn_Error ndn_BinaryXMLEncoder_writeTimeMillisecondsDTagElement(struct ndn_BinaryXMLEncoder *self, unsigned int tag, double milliseconds);
+ndn_Error ndn_BinaryXmlEncoder_writeTimeMillisecondsDTagElement(struct ndn_BinaryXmlEncoder *self, unsigned int tag, double milliseconds);
 
 /**
- * If milliseconds is negative then do nothing, otherwise call ndn_BinaryXMLEncoder_writeTimeMillisecondsDTagElement.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * If milliseconds is negative then do nothing, otherwise call ndn_BinaryXmlEncoder_writeTimeMillisecondsDTagElement.
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
  * @param tag the DTAG tag
  * @param milliseconds negative for none, otherwise the number of milliseconds
  * @return 0 for success, else an error code
  */
-static inline ndn_Error ndn_BinaryXMLEncoder_writeOptionalTimeMillisecondsDTagElement
-  (struct ndn_BinaryXMLEncoder *self, unsigned int tag, double milliseconds)
+static inline ndn_Error ndn_BinaryXmlEncoder_writeOptionalTimeMillisecondsDTagElement
+  (struct ndn_BinaryXmlEncoder *self, unsigned int tag, double milliseconds)
 {
   if (milliseconds >= 0)
-    return ndn_BinaryXMLEncoder_writeTimeMillisecondsDTagElement(self, tag, milliseconds);
+    return ndn_BinaryXmlEncoder_writeTimeMillisecondsDTagElement(self, tag, milliseconds);
   else
     return (ndn_Error)0;
 }
diff --git a/ndn-cpp/c/encoding/BinaryXMLInterest.c b/ndn-cpp/c/encoding/BinaryXMLInterest.c
index 713d4f2..953f76d 100644
--- a/ndn-cpp/c/encoding/BinaryXMLInterest.c
+++ b/ndn-cpp/c/encoding/BinaryXMLInterest.c
@@ -10,13 +10,13 @@
 #include "BinaryXMLPublisherPublicKeyDigest.h"
 #include "BinaryXMLInterest.h"
 
-static ndn_Error encodeExclude(struct ndn_Exclude *exclude, struct ndn_BinaryXMLEncoder *encoder)
+static ndn_Error encodeExclude(struct ndn_Exclude *exclude, struct ndn_BinaryXmlEncoder *encoder)
 {
   if (exclude->nEntries == 0)
     return 0;
   
   ndn_Error error;
-  if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(encoder, ndn_BinaryXML_DTag_Exclude))
+  if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(encoder, ndn_BinaryXml_DTag_Exclude))
     return error;
   
   // TODO: Do we want to order the components (except for ANY)?
@@ -25,43 +25,43 @@
     struct ndn_ExcludeEntry *entry = &exclude->entries[i];
     
     if (entry->type == ndn_Exclude_COMPONENT) {
-      if (error = ndn_BinaryXMLEncoder_writeBlobDTagElement
-          (encoder, ndn_BinaryXML_DTag_Component, entry->component, entry->componentLength))
+      if (error = ndn_BinaryXmlEncoder_writeBlobDTagElement
+          (encoder, ndn_BinaryXml_DTag_Component, entry->component, entry->componentLength))
         return error;
     }
     else if (entry->type == ndn_Exclude_ANY) {
-      if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(encoder, ndn_BinaryXML_DTag_Any))
+      if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(encoder, ndn_BinaryXml_DTag_Any))
         return error;
-    	if (error = ndn_BinaryXMLEncoder_writeElementClose(encoder))
+    	if (error = ndn_BinaryXmlEncoder_writeElementClose(encoder))
         return error;
     }
     else
       return NDN_ERROR_unrecognized_ndn_ExcludeType;
 	}
   
-	if (error = ndn_BinaryXMLEncoder_writeElementClose(encoder))
+	if (error = ndn_BinaryXmlEncoder_writeElementClose(encoder))
     return error;
   
   return 0;  
 }
 
-static ndn_Error decodeExclude(struct ndn_Exclude *exclude, struct ndn_BinaryXMLDecoder *decoder)
+static ndn_Error decodeExclude(struct ndn_Exclude *exclude, struct ndn_BinaryXmlDecoder *decoder)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLDecoder_readElementStartDTag(decoder, ndn_BinaryXML_DTag_Exclude))
+  if (error = ndn_BinaryXmlDecoder_readElementStartDTag(decoder, ndn_BinaryXml_DTag_Exclude))
     return error;
     
   exclude->nEntries = 0;
   while (1) {
     int gotExpectedTag;
     
-    if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_Component, &gotExpectedTag))
+    if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_Component, &gotExpectedTag))
       return error;    
     if (gotExpectedTag) {
       // Component
       unsigned char *component;
       unsigned int componentLen;
-      if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement(decoder, ndn_BinaryXML_DTag_Component, 0, &component, &componentLen))
+      if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement(decoder, ndn_BinaryXml_DTag_Component, 0, &component, &componentLen))
         return error;
     
       // Add the component entry.
@@ -73,13 +73,13 @@
       continue;
     }
     
-    if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_Any, &gotExpectedTag))
+    if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_Any, &gotExpectedTag))
       return error;    
     if (gotExpectedTag) {
       // Any
-      if (error = ndn_BinaryXMLDecoder_readElementStartDTag(decoder, ndn_BinaryXML_DTag_Any))
+      if (error = ndn_BinaryXmlDecoder_readElementStartDTag(decoder, ndn_BinaryXml_DTag_Any))
         return error;
-      if (error = ndn_BinaryXMLDecoder_readElementClose(decoder))
+      if (error = ndn_BinaryXmlDecoder_readElementClose(decoder))
         return error;
     
       // Add the any entry.
@@ -91,13 +91,13 @@
       continue;
     }
     
-    if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_Bloom, &gotExpectedTag))
+    if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_Bloom, &gotExpectedTag))
       return error;    
     if (gotExpectedTag) {
       // Skip the Bloom and treat it as Any.
       unsigned char *value;
       unsigned int valueLen;
-      if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement(decoder, ndn_BinaryXML_DTag_Bloom, 0, &value, &valueLen))
+      if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement(decoder, ndn_BinaryXml_DTag_Bloom, 0, &value, &valueLen))
         return error;
     
       // Add the any entry.
@@ -113,83 +113,83 @@
     break;
   }
   
-  if (error = ndn_BinaryXMLDecoder_readElementClose(decoder))
+  if (error = ndn_BinaryXmlDecoder_readElementClose(decoder))
     return error;
   
   return 0;
 }
 
-ndn_Error ndn_encodeBinaryXMLInterest(struct ndn_Interest *interest, struct ndn_BinaryXMLEncoder *encoder)
+ndn_Error ndn_encodeBinaryXmlInterest(struct ndn_Interest *interest, struct ndn_BinaryXmlEncoder *encoder)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(encoder, ndn_BinaryXML_DTag_Interest))
+  if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(encoder, ndn_BinaryXml_DTag_Interest))
     return error;
     
-  if (error = ndn_encodeBinaryXMLName(&interest->name, encoder))
+  if (error = ndn_encodeBinaryXmlName(&interest->name, encoder))
     return error;
   
-  if (error = ndn_BinaryXMLEncoder_writeOptionalUnsignedDecimalIntDTagElement
-      (encoder, ndn_BinaryXML_DTag_MinSuffixComponents, interest->minSuffixComponents))
+  if (error = ndn_BinaryXmlEncoder_writeOptionalUnsignedDecimalIntDTagElement
+      (encoder, ndn_BinaryXml_DTag_MinSuffixComponents, interest->minSuffixComponents))
     return error;
-  if (error = ndn_BinaryXMLEncoder_writeOptionalUnsignedDecimalIntDTagElement
-      (encoder, ndn_BinaryXML_DTag_MaxSuffixComponents, interest->maxSuffixComponents))
+  if (error = ndn_BinaryXmlEncoder_writeOptionalUnsignedDecimalIntDTagElement
+      (encoder, ndn_BinaryXml_DTag_MaxSuffixComponents, interest->maxSuffixComponents))
     return error;
     
   // This will skip encoding if there is no publisherPublicKeyDigest.
-  if (error = ndn_encodeBinaryXMLPublisherPublicKeyDigest(&interest->publisherPublicKeyDigest, encoder))
+  if (error = ndn_encodeBinaryXmlPublisherPublicKeyDigest(&interest->publisherPublicKeyDigest, encoder))
     return error;
   
   // This will skip encoding if there is no exclude.
   if (error = encodeExclude(&interest->exclude, encoder))
     return error;
 
-  if (error = ndn_BinaryXMLEncoder_writeOptionalUnsignedDecimalIntDTagElement
-      (encoder, ndn_BinaryXML_DTag_ChildSelector, interest->childSelector))
+  if (error = ndn_BinaryXmlEncoder_writeOptionalUnsignedDecimalIntDTagElement
+      (encoder, ndn_BinaryXml_DTag_ChildSelector, interest->childSelector))
     return error;
   if (interest->answerOriginKind >= 0 && interest->answerOriginKind != ndn_Interest_DEFAULT_ANSWER_ORIGIN_KIND) {
-    if (error = ndn_BinaryXMLEncoder_writeUnsignedDecimalIntDTagElement
-        (encoder, ndn_BinaryXML_DTag_AnswerOriginKind, (unsigned int)interest->answerOriginKind))
+    if (error = ndn_BinaryXmlEncoder_writeUnsignedDecimalIntDTagElement
+        (encoder, ndn_BinaryXml_DTag_AnswerOriginKind, (unsigned int)interest->answerOriginKind))
       return error;
   }
-  if (error = ndn_BinaryXMLEncoder_writeOptionalUnsignedDecimalIntDTagElement
-      (encoder, ndn_BinaryXML_DTag_Scope, interest->scope))
+  if (error = ndn_BinaryXmlEncoder_writeOptionalUnsignedDecimalIntDTagElement
+      (encoder, ndn_BinaryXml_DTag_Scope, interest->scope))
     return error;
   
-  if (error = ndn_BinaryXMLEncoder_writeOptionalTimeMillisecondsDTagElement
-      (encoder, ndn_BinaryXML_DTag_InterestLifetime, interest->interestLifetimeMilliseconds))
+  if (error = ndn_BinaryXmlEncoder_writeOptionalTimeMillisecondsDTagElement
+      (encoder, ndn_BinaryXml_DTag_InterestLifetime, interest->interestLifetimeMilliseconds))
     return error;
   
-  if (error = ndn_BinaryXMLEncoder_writeOptionalBlobDTagElement
-      (encoder, ndn_BinaryXML_DTag_Nonce, interest->nonce, interest->nonceLength))
+  if (error = ndn_BinaryXmlEncoder_writeOptionalBlobDTagElement
+      (encoder, ndn_BinaryXml_DTag_Nonce, interest->nonce, interest->nonceLength))
     return error;
   
-	if (error = ndn_BinaryXMLEncoder_writeElementClose(encoder))
+	if (error = ndn_BinaryXmlEncoder_writeElementClose(encoder))
     return error;
   
   return 0;  
 }
 
-ndn_Error ndn_decodeBinaryXMLInterest(struct ndn_Interest *interest, struct ndn_BinaryXMLDecoder *decoder)
+ndn_Error ndn_decodeBinaryXmlInterest(struct ndn_Interest *interest, struct ndn_BinaryXmlDecoder *decoder)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLDecoder_readElementStartDTag(decoder, ndn_BinaryXML_DTag_Interest))
+  if (error = ndn_BinaryXmlDecoder_readElementStartDTag(decoder, ndn_BinaryXml_DTag_Interest))
     return error;
     
-  if (error = ndn_decodeBinaryXMLName(&interest->name, decoder))
+  if (error = ndn_decodeBinaryXmlName(&interest->name, decoder))
     return error;
        
-  if (error = ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement
-      (decoder, ndn_BinaryXML_DTag_MinSuffixComponents, &interest->minSuffixComponents))
+  if (error = ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+      (decoder, ndn_BinaryXml_DTag_MinSuffixComponents, &interest->minSuffixComponents))
     return error;
-  if (error = ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement
-      (decoder, ndn_BinaryXML_DTag_MaxSuffixComponents, &interest->maxSuffixComponents))
+  if (error = ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+      (decoder, ndn_BinaryXml_DTag_MaxSuffixComponents, &interest->maxSuffixComponents))
     return error;
   
-  if (error = ndn_decodeOptionalBinaryXMLPublisherPublicKeyDigest(&interest->publisherPublicKeyDigest, decoder))
+  if (error = ndn_decodeOptionalBinaryXmlPublisherPublicKeyDigest(&interest->publisherPublicKeyDigest, decoder))
     return error;
   
   int gotExpectedTag;
-  if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_Exclude, &gotExpectedTag))
+  if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_Exclude, &gotExpectedTag))
     return error;
   if (gotExpectedTag) {
     if (error = decodeExclude(&interest->exclude, decoder))
@@ -198,25 +198,25 @@
   else
     interest->exclude.nEntries = 0;
   
-  if (error = ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement
-      (decoder, ndn_BinaryXML_DTag_ChildSelector, &interest->childSelector))
+  if (error = ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+      (decoder, ndn_BinaryXml_DTag_ChildSelector, &interest->childSelector))
     return error;
-  if (error = ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement
-      (decoder, ndn_BinaryXML_DTag_AnswerOriginKind, &interest->answerOriginKind))
+  if (error = ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+      (decoder, ndn_BinaryXml_DTag_AnswerOriginKind, &interest->answerOriginKind))
     return error;
-  if (error = ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement
-      (decoder, ndn_BinaryXML_DTag_Scope, &interest->scope))
+  if (error = ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+      (decoder, ndn_BinaryXml_DTag_Scope, &interest->scope))
     return error;
   
-  if (error= ndn_BinaryXMLDecoder_readOptionalTimeMillisecondsDTagElement
-      (decoder, ndn_BinaryXML_DTag_InterestLifetime, &interest->interestLifetimeMilliseconds))
+  if (error= ndn_BinaryXmlDecoder_readOptionalTimeMillisecondsDTagElement
+      (decoder, ndn_BinaryXml_DTag_InterestLifetime, &interest->interestLifetimeMilliseconds))
     return error;
   
-  if (error = ndn_BinaryXMLDecoder_readOptionalBinaryDTagElement
-      (decoder, ndn_BinaryXML_DTag_Nonce, 0, &interest->nonce, &interest->nonceLength))
+  if (error = ndn_BinaryXmlDecoder_readOptionalBinaryDTagElement
+      (decoder, ndn_BinaryXml_DTag_Nonce, 0, &interest->nonce, &interest->nonceLength))
     return error;
 
-  if (error = ndn_BinaryXMLDecoder_readElementClose(decoder))
+  if (error = ndn_BinaryXmlDecoder_readElementClose(decoder))
     return error;
   
   return 0;
diff --git a/ndn-cpp/c/encoding/BinaryXMLInterest.h b/ndn-cpp/c/encoding/BinaryXMLInterest.h
index 9a58b78..960871f 100644
--- a/ndn-cpp/c/encoding/BinaryXMLInterest.h
+++ b/ndn-cpp/c/encoding/BinaryXMLInterest.h
@@ -15,9 +15,9 @@
 extern "C" {
 #endif
 
-ndn_Error ndn_encodeBinaryXMLInterest(struct ndn_Interest *interest, struct ndn_BinaryXMLEncoder *encoder);
+ndn_Error ndn_encodeBinaryXmlInterest(struct ndn_Interest *interest, struct ndn_BinaryXmlEncoder *encoder);
 
-ndn_Error ndn_decodeBinaryXMLInterest(struct ndn_Interest *interest, struct ndn_BinaryXMLDecoder *decoder);
+ndn_Error ndn_decodeBinaryXmlInterest(struct ndn_Interest *interest, struct ndn_BinaryXmlDecoder *decoder);
 
 #ifdef	__cplusplus
 }
diff --git a/ndn-cpp/c/encoding/BinaryXMLKey.c b/ndn-cpp/c/encoding/BinaryXMLKey.c
index b7583ef..e7e7f41 100644
--- a/ndn-cpp/c/encoding/BinaryXMLKey.c
+++ b/ndn-cpp/c/encoding/BinaryXMLKey.c
@@ -8,23 +8,23 @@
 #include "BinaryXMLStructureDecoder.h"
 #include "BinaryXMLKey.h"
 
-ndn_Error ndn_encodeBinaryXMLKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXMLEncoder *encoder)
+ndn_Error ndn_encodeBinaryXmlKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXmlEncoder *encoder)
 {
   if (keyLocator->type < 0)
     return 0;
 
   ndn_Error error;
-  if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(encoder, ndn_BinaryXML_DTag_KeyLocator))
+  if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(encoder, ndn_BinaryXml_DTag_KeyLocator))
     return error;
 
   if (keyLocator->type == ndn_KeyLocatorType_KEY) {
-    if (error = ndn_BinaryXMLEncoder_writeBlobDTagElement
-        (encoder, ndn_BinaryXML_DTag_Key, keyLocator->keyOrCertificate, keyLocator->keyOrCertificateLength))
+    if (error = ndn_BinaryXmlEncoder_writeBlobDTagElement
+        (encoder, ndn_BinaryXml_DTag_Key, keyLocator->keyOrCertificate, keyLocator->keyOrCertificateLength))
       return error;    
   }
   else if (keyLocator->type == ndn_KeyLocatorType_CERTIFICATE) {
-    if (error = ndn_BinaryXMLEncoder_writeBlobDTagElement
-        (encoder, ndn_BinaryXML_DTag_Certificate, keyLocator->keyOrCertificate, keyLocator->keyOrCertificateLength))
+    if (error = ndn_BinaryXmlEncoder_writeBlobDTagElement
+        (encoder, ndn_BinaryXml_DTag_Certificate, keyLocator->keyOrCertificate, keyLocator->keyOrCertificateLength))
       return error;    
   }
   else if (keyLocator->type == ndn_KeyLocatorType_KEYNAME) {
@@ -33,72 +33,72 @@
   else
     return NDN_ERROR_unrecognized_ndn_KeyLocatorType;
   
-	if (error = ndn_BinaryXMLEncoder_writeElementClose(encoder))
+	if (error = ndn_BinaryXmlEncoder_writeElementClose(encoder))
     return error;
   
   return 0;
 }
 
-ndn_Error ndn_decodeBinaryXMLKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXMLDecoder *decoder)
+ndn_Error ndn_decodeBinaryXmlKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXmlDecoder *decoder)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLDecoder_readElementStartDTag(decoder, ndn_BinaryXML_DTag_KeyLocator))
+  if (error = ndn_BinaryXmlDecoder_readElementStartDTag(decoder, ndn_BinaryXml_DTag_KeyLocator))
     return error;
 
   int gotExpectedTag;
-  if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_Key, &gotExpectedTag))
+  if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_Key, &gotExpectedTag))
     return error;
   if (gotExpectedTag) {
     keyLocator->type = ndn_KeyLocatorType_KEY;
     
-    if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement
-        (decoder, ndn_BinaryXML_DTag_Key, 0, &keyLocator->keyOrCertificate, &keyLocator->keyOrCertificateLength))
+    if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement
+        (decoder, ndn_BinaryXml_DTag_Key, 0, &keyLocator->keyOrCertificate, &keyLocator->keyOrCertificateLength))
       return error;
   }
   else {
-    if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_Certificate, &gotExpectedTag))
+    if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_Certificate, &gotExpectedTag))
       return error;
     if (gotExpectedTag) {
       keyLocator->type = ndn_KeyLocatorType_CERTIFICATE;
     
-      if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement
-          (decoder, ndn_BinaryXML_DTag_Certificate, 0, &keyLocator->keyOrCertificate, &keyLocator->keyOrCertificateLength))
+      if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement
+          (decoder, ndn_BinaryXml_DTag_Certificate, 0, &keyLocator->keyOrCertificate, &keyLocator->keyOrCertificateLength))
         return error;
     }
     else {
-      if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_KeyName, &gotExpectedTag))
+      if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_KeyName, &gotExpectedTag))
         return error;
       if (gotExpectedTag) {
         // TODO: Implement keyName. For now, just use a structure decoder to skip it.
-        struct ndn_BinaryXMLStructureDecoder structureDecoder;
-        ndn_BinaryXMLStructureDecoder_init(&structureDecoder);
+        struct ndn_BinaryXmlStructureDecoder structureDecoder;
+        ndn_BinaryXmlStructureDecoder_init(&structureDecoder);
         
-        ndn_BinaryXMLStructureDecoder_seek(&structureDecoder, decoder->offset);
-        if (error = ndn_BinaryXMLStructureDecoder_findElementEnd(&structureDecoder, decoder->input, decoder->inputLength))
+        ndn_BinaryXmlStructureDecoder_seek(&structureDecoder, decoder->offset);
+        if (error = ndn_BinaryXmlStructureDecoder_findElementEnd(&structureDecoder, decoder->input, decoder->inputLength))
           return error;
         if (!structureDecoder.gotElementEnd)
           return NDN_ERROR_read_past_the_end_of_the_input;
-        ndn_BinaryXMLDecoder_seek(decoder, structureDecoder.offset);        
+        ndn_BinaryXmlDecoder_seek(decoder, structureDecoder.offset);        
       }
       else
-        return NDN_ERROR_decodeBinaryXMLKeyLocator_unrecognized_key_locator_type;
+        return NDN_ERROR_decodeBinaryXmlKeyLocator_unrecognized_key_locator_type;
     }
   }
 
-  if (error = ndn_BinaryXMLDecoder_readElementClose(decoder))
+  if (error = ndn_BinaryXmlDecoder_readElementClose(decoder))
     return error;
   
   return 0;
 }
 
-ndn_Error ndn_decodeOptionalBinaryXMLKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXMLDecoder *decoder)
+ndn_Error ndn_decodeOptionalBinaryXmlKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXmlDecoder *decoder)
 {
   int gotExpectedTag;
   ndn_Error error; 
-  if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_KeyLocator, &gotExpectedTag))
+  if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_KeyLocator, &gotExpectedTag))
     return error;
   if (gotExpectedTag) {
-    if (error = ndn_decodeBinaryXMLKeyLocator(keyLocator, decoder))
+    if (error = ndn_decodeBinaryXmlKeyLocator(keyLocator, decoder))
       return error;
   }
   else
diff --git a/ndn-cpp/c/encoding/BinaryXMLKey.h b/ndn-cpp/c/encoding/BinaryXMLKey.h
index 8896dd6..8ccbcac 100644
--- a/ndn-cpp/c/encoding/BinaryXMLKey.h
+++ b/ndn-cpp/c/encoding/BinaryXMLKey.h
@@ -18,27 +18,27 @@
 /**
  * Encode the ndn_KeyLocator struct using Binary XML.  If keyLocator->type is -1, then do nothing. 
  * @param keyLocator pointer to the ndn_KeyLocator struct
- * @param encoder pointer to the ndn_BinaryXMLEncoder struct
+ * @param encoder pointer to the ndn_BinaryXmlEncoder struct
  * @return 0 for success, else an error code
  */
-ndn_Error ndn_encodeBinaryXMLKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXMLEncoder *encoder);
+ndn_Error ndn_encodeBinaryXmlKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXmlEncoder *encoder);
 
 /**
  * Expect the next element to be a Binary XML KeyLocator and decode into the ndn_KeyLocator struct.
  * @param keyLocator pointer to the ndn_KeyLocator struct
- * @param decoder pointer to the ndn_BinaryXMLDecoder struct
+ * @param decoder pointer to the ndn_BinaryXmlDecoder struct
  * @return 0 for success, else an error code, including if the next element is not KeyLocator.
  */
-ndn_Error ndn_decodeBinaryXMLKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXMLDecoder *decoder);
+ndn_Error ndn_decodeBinaryXmlKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXmlDecoder *decoder);
 
 /**
  * Peek the next element and if it is a Binary XML KeyLocator and decode into the ndn_KeyLocator struct.
  * Otherwise, set the ndn_KeyLocator struct to none.
  * @param keyLocator pointer to the ndn_KeyLocator struct
- * @param decoder pointer to the ndn_BinaryXMLDecoder struct
+ * @param decoder pointer to the ndn_BinaryXmlDecoder struct
  * @return 0 for success, else an error code, including if the next element is not KeyLocator.
  */
-ndn_Error ndn_decodeOptionalBinaryXMLKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXMLDecoder *decoder);
+ndn_Error ndn_decodeOptionalBinaryXmlKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXmlDecoder *decoder);
 
 #ifdef	__cplusplus
 }
diff --git a/ndn-cpp/c/encoding/BinaryXMLName.c b/ndn-cpp/c/encoding/BinaryXMLName.c
index f75c1ea..97adda0 100644
--- a/ndn-cpp/c/encoding/BinaryXMLName.c
+++ b/ndn-cpp/c/encoding/BinaryXMLName.c
@@ -8,35 +8,35 @@
 #include "BinaryXMLDecoder.h"
 #include "BinaryXMLName.h"
 
-ndn_Error ndn_encodeBinaryXMLName(struct ndn_Name *name, struct ndn_BinaryXMLEncoder *encoder)
+ndn_Error ndn_encodeBinaryXmlName(struct ndn_Name *name, struct ndn_BinaryXmlEncoder *encoder)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(encoder, ndn_BinaryXML_DTag_Name))
+  if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(encoder, ndn_BinaryXml_DTag_Name))
     return error;
   
   unsigned int i;
   for (i = 0; i < name->nComponents; ++i) {
-    if (error = ndn_BinaryXMLEncoder_writeBlobDTagElement
-        (encoder, ndn_BinaryXML_DTag_Component, name->components[i].value, name->components[i].valueLength))
+    if (error = ndn_BinaryXmlEncoder_writeBlobDTagElement
+        (encoder, ndn_BinaryXml_DTag_Component, name->components[i].value, name->components[i].valueLength))
       return error;
 	}
   
-	if (error = ndn_BinaryXMLEncoder_writeElementClose(encoder))
+	if (error = ndn_BinaryXmlEncoder_writeElementClose(encoder))
     return error;
   
   return 0;
 }
 
-ndn_Error ndn_decodeBinaryXMLName(struct ndn_Name *name, struct ndn_BinaryXMLDecoder *decoder)
+ndn_Error ndn_decodeBinaryXmlName(struct ndn_Name *name, struct ndn_BinaryXmlDecoder *decoder)
 {
   ndn_Error error;
-  if (error = ndn_BinaryXMLDecoder_readElementStartDTag(decoder, ndn_BinaryXML_DTag_Name))
+  if (error = ndn_BinaryXmlDecoder_readElementStartDTag(decoder, ndn_BinaryXml_DTag_Name))
     return error;
     
   name->nComponents = 0;
   while (1) {
     int gotExpectedTag;
-    if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_Component, &gotExpectedTag))
+    if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_Component, &gotExpectedTag))
       return error;
     
     if (!gotExpectedTag)
@@ -45,7 +45,7 @@
     
     unsigned char *component;
     unsigned int componentLen;
-    if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement(decoder, ndn_BinaryXML_DTag_Component, 0, &component, &componentLen))
+    if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement(decoder, ndn_BinaryXml_DTag_Component, 0, &component, &componentLen))
       return error;
     
     // Add the component to the name.
@@ -55,7 +55,7 @@
     ++name->nComponents;
   }
   
-  if (error = ndn_BinaryXMLDecoder_readElementClose(decoder))
+  if (error = ndn_BinaryXmlDecoder_readElementClose(decoder))
     return error;
   
   return 0;
diff --git a/ndn-cpp/c/encoding/BinaryXMLName.h b/ndn-cpp/c/encoding/BinaryXMLName.h
index 0dee306..f165c4b 100644
--- a/ndn-cpp/c/encoding/BinaryXMLName.h
+++ b/ndn-cpp/c/encoding/BinaryXMLName.h
@@ -15,9 +15,9 @@
 extern "C" {
 #endif
 
-ndn_Error ndn_encodeBinaryXMLName(struct ndn_Name *name, struct ndn_BinaryXMLEncoder *encoder);
+ndn_Error ndn_encodeBinaryXmlName(struct ndn_Name *name, struct ndn_BinaryXmlEncoder *encoder);
 
-ndn_Error ndn_decodeBinaryXMLName(struct ndn_Name *name, struct ndn_BinaryXMLDecoder *decoder);
+ndn_Error ndn_decodeBinaryXmlName(struct ndn_Name *name, struct ndn_BinaryXmlDecoder *decoder);
 
 #ifdef	__cplusplus
 }
diff --git a/ndn-cpp/c/encoding/BinaryXMLPublisherPublicKeyDigest.c b/ndn-cpp/c/encoding/BinaryXMLPublisherPublicKeyDigest.c
index 00e3582..8a1fe63 100644
--- a/ndn-cpp/c/encoding/BinaryXMLPublisherPublicKeyDigest.c
+++ b/ndn-cpp/c/encoding/BinaryXMLPublisherPublicKeyDigest.c
@@ -7,42 +7,42 @@
 #include "BinaryXML.h"
 #include "BinaryXMLPublisherPublicKeyDigest.h"
 
-ndn_Error ndn_encodeBinaryXMLPublisherPublicKeyDigest
-  (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXMLEncoder *encoder)
+ndn_Error ndn_encodeBinaryXmlPublisherPublicKeyDigest
+  (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXmlEncoder *encoder)
 {  
   if (!publisherPublicKeyDigest->publisherPublicKeyDigest || publisherPublicKeyDigest->publisherPublicKeyDigestLength == 0)
     return;
   
   ndn_Error error;
-  if (error = ndn_BinaryXMLEncoder_writeBlobDTagElement
-      (encoder, ndn_BinaryXML_DTag_PublisherPublicKeyDigest, publisherPublicKeyDigest->publisherPublicKeyDigest, 
+  if (error = ndn_BinaryXmlEncoder_writeBlobDTagElement
+      (encoder, ndn_BinaryXml_DTag_PublisherPublicKeyDigest, publisherPublicKeyDigest->publisherPublicKeyDigest, 
        publisherPublicKeyDigest->publisherPublicKeyDigestLength))
     return error;
   
   return 0;
 }
 
-ndn_Error ndn_decodeBinaryXMLPublisherPublicKeyDigest
-  (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXMLDecoder *decoder)
+ndn_Error ndn_decodeBinaryXmlPublisherPublicKeyDigest
+  (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXmlDecoder *decoder)
 {
   ndn_Error error; 
-  if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement
-      (decoder, ndn_BinaryXML_DTag_PublisherPublicKeyDigest, 0, &publisherPublicKeyDigest->publisherPublicKeyDigest,
+  if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement
+      (decoder, ndn_BinaryXml_DTag_PublisherPublicKeyDigest, 0, &publisherPublicKeyDigest->publisherPublicKeyDigest,
        &publisherPublicKeyDigest->publisherPublicKeyDigestLength))
     return error;
   
   return 0;
 }
 
-ndn_Error ndn_decodeOptionalBinaryXMLPublisherPublicKeyDigest
-  (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXMLDecoder *decoder)
+ndn_Error ndn_decodeOptionalBinaryXmlPublisherPublicKeyDigest
+  (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXmlDecoder *decoder)
 {
   int gotExpectedTag;
   ndn_Error error; 
-  if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_PublisherPublicKeyDigest, &gotExpectedTag))
+  if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_PublisherPublicKeyDigest, &gotExpectedTag))
     return error;
   if (gotExpectedTag) {
-    if (error = ndn_decodeBinaryXMLPublisherPublicKeyDigest(publisherPublicKeyDigest, decoder))
+    if (error = ndn_decodeBinaryXmlPublisherPublicKeyDigest(publisherPublicKeyDigest, decoder))
       return error;
   }
   else {
diff --git a/ndn-cpp/c/encoding/BinaryXMLPublisherPublicKeyDigest.h b/ndn-cpp/c/encoding/BinaryXMLPublisherPublicKeyDigest.h
index 178a767..eb3e2a8 100644
--- a/ndn-cpp/c/encoding/BinaryXMLPublisherPublicKeyDigest.h
+++ b/ndn-cpp/c/encoding/BinaryXMLPublisherPublicKeyDigest.h
@@ -19,30 +19,30 @@
  * Encode the ndn_PublisherPublicKeyDigest struct using Binary XML.  If publisherPublicKeyDigest->publisherPublicKeyDigest or
  * publisherPublicKeyDigestLength is 0, then do nothing. 
  * @param publisherPublicKeyDigest pointer to the ndn_PublisherPublicKeyDigest struct
- * @param encoder pointer to the ndn_BinaryXMLEncoder struct
+ * @param encoder pointer to the ndn_BinaryXmlEncoder struct
  * @return 0 for success, else an error code
  */
-ndn_Error ndn_encodeBinaryXMLPublisherPublicKeyDigest
-  (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXMLEncoder *encoder);
+ndn_Error ndn_encodeBinaryXmlPublisherPublicKeyDigest
+  (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXmlEncoder *encoder);
 
 /**
  * Expect the next element to be a Binary XML PublisherPublicKeyDigest and decode into the ndn_PublisherPublicKeyDigest struct.
  * @param publisherPublicKeyDigest pointer to the ndn_PublisherPublicKeyDigest struct
- * @param decoder pointer to the ndn_BinaryXMLDecoder struct
+ * @param decoder pointer to the ndn_BinaryXmlDecoder struct
  * @return 0 for success, else an error code, including if the next element is not PublisherPublicKeyDigest.
  */
-ndn_Error ndn_decodeBinaryXMLPublisherPublicKeyDigest
-  (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXMLDecoder *decoder);
+ndn_Error ndn_decodeBinaryXmlPublisherPublicKeyDigest
+  (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXmlDecoder *decoder);
 
 /**
  * Peek the next element and if it is a Binary XML PublisherPublicKeyDigest and decode into the ndn_PublisherPublicKeyDigest struct.
  * Otherwise, set the ndn_PublisherPublicKeyDigest struct to none.
  * @param publisherPublicKeyDigest pointer to the ndn_PublisherPublicKeyDigest struct
- * @param decoder pointer to the ndn_BinaryXMLDecoder struct
+ * @param decoder pointer to the ndn_BinaryXmlDecoder struct
  * @return 0 for success, else an error code, including if the next element is not PublisherPublicKeyDigest.
  */
-ndn_Error ndn_decodeOptionalBinaryXMLPublisherPublicKeyDigest
-  (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXMLDecoder *decoder);
+ndn_Error ndn_decodeOptionalBinaryXmlPublisherPublicKeyDigest
+  (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXmlDecoder *decoder);
 
 #ifdef	__cplusplus
 }
diff --git a/ndn-cpp/c/encoding/BinaryXMLStructureDecoder.c b/ndn-cpp/c/encoding/BinaryXMLStructureDecoder.c
index f9d7dda..dbd4ac5 100644
--- a/ndn-cpp/c/encoding/BinaryXMLStructureDecoder.c
+++ b/ndn-cpp/c/encoding/BinaryXMLStructureDecoder.c
@@ -8,12 +8,12 @@
 #include "BinaryXMLDecoder.h"
 #include "BinaryXMLStructureDecoder.h"
 
-void ndn_BinaryXMLStructureDecoder_init(struct ndn_BinaryXMLStructureDecoder *self) 
+void ndn_BinaryXmlStructureDecoder_init(struct ndn_BinaryXmlStructureDecoder *self) 
 {
   self->gotElementEnd = 0;
   self->offset = 0;
   self->level = 0;
-  self->state = ndn_BinaryXMLStructureDecoder_READ_HEADER_OR_CLOSE;
+  self->state = ndn_BinaryXmlStructureDecoder_READ_HEADER_OR_CLOSE;
   self->headerLength = 0;
   self->useHeaderBuffer = 0;
   self->nBytesToRead = 0;
@@ -22,31 +22,31 @@
 /**
  * Set the state to READ_HEADER_OR_CLOSE and set up to start reading the header.
  */
-static inline void startHeader(struct ndn_BinaryXMLStructureDecoder *self)
+static inline void startHeader(struct ndn_BinaryXmlStructureDecoder *self)
 {
   self->headerLength = 0;
   self->useHeaderBuffer = 0;
-  self->state = ndn_BinaryXMLStructureDecoder_READ_HEADER_OR_CLOSE;    
+  self->state = ndn_BinaryXmlStructureDecoder_READ_HEADER_OR_CLOSE;    
 }
 
-ndn_Error ndn_BinaryXMLStructureDecoder_findElementEnd
-  (struct ndn_BinaryXMLStructureDecoder *self, unsigned char *input, unsigned int inputLength) 
+ndn_Error ndn_BinaryXmlStructureDecoder_findElementEnd
+  (struct ndn_BinaryXmlStructureDecoder *self, unsigned char *input, unsigned int inputLength) 
 {
   if (self->gotElementEnd)
     // Someone is calling when we already got the end.
     return 0;
   
-  struct ndn_BinaryXMLDecoder decoder;
-  ndn_BinaryXMLDecoder_init(&decoder, input, inputLength);
+  struct ndn_BinaryXmlDecoder decoder;
+  ndn_BinaryXmlDecoder_init(&decoder, input, inputLength);
   
   while (1) {
     if (self->offset >= inputLength)
       // All the cases assume we have some input. Return and wait for more.
       return 0;
     
-    if (self->state == ndn_BinaryXMLStructureDecoder_READ_HEADER_OR_CLOSE) {
+    if (self->state == ndn_BinaryXmlStructureDecoder_READ_HEADER_OR_CLOSE) {
       // First check for CLOSE.
-      if (self->headerLength == 0 && input[self->offset] == ndn_BinaryXML_CLOSE) {
+      if (self->headerLength == 0 && input[self->offset] == ndn_BinaryXml_CLOSE) {
         ++self->offset;
         // Close the level.
         --self->level;
@@ -77,7 +77,7 @@
         }
         unsigned int headerByte = (unsigned int)input[self->offset++];
         ++self->headerLength;
-        if (headerByte & ndn_BinaryXML_TT_FINAL)
+        if (headerByte & ndn_BinaryXml_TT_FINAL)
           // Break and read the header.
           break;
       }
@@ -92,45 +92,45 @@
         ndn_memcpy(self->headerBuffer + startingHeaderLength, input + (self->offset - nNewBytes), nNewBytes);
 
         // Use a local decoder just for the headerBuffer.
-        struct ndn_BinaryXMLDecoder bufferDecoder;
-        ndn_BinaryXMLDecoder_init(&bufferDecoder, self->headerBuffer, sizeof(self->headerBuffer));
-        if (ndn_BinaryXMLDecoder_decodeTypeAndValue(&bufferDecoder, &type, &value))
+        struct ndn_BinaryXmlDecoder bufferDecoder;
+        ndn_BinaryXmlDecoder_init(&bufferDecoder, self->headerBuffer, sizeof(self->headerBuffer));
+        if (ndn_BinaryXmlDecoder_decodeTypeAndValue(&bufferDecoder, &type, &value))
           return NDN_ERROR_findElementEnd_cannot_read_header_type_and_value;
       }
       else {
         // We didn't have to use the headerBuffer.
-        ndn_BinaryXMLDecoder_seek(&decoder, self->offset - self->headerLength);
-        if (ndn_BinaryXMLDecoder_decodeTypeAndValue(&decoder, &type, &value))
+        ndn_BinaryXmlDecoder_seek(&decoder, self->offset - self->headerLength);
+        if (ndn_BinaryXmlDecoder_decodeTypeAndValue(&decoder, &type, &value))
           return NDN_ERROR_findElementEnd_cannot_read_header_type_and_value;
       }
         
       // Set the next state based on the type.
-      if (type == ndn_BinaryXML_DATTR)
+      if (type == ndn_BinaryXml_DATTR)
         // We already consumed the item. READ_HEADER_OR_CLOSE again.
         // Binary XML has rules about what must follow an attribute, but we are just scanning.
         startHeader(self);
-      else if (type == ndn_BinaryXML_DTAG || type == ndn_BinaryXML_EXT) {
+      else if (type == ndn_BinaryXml_DTAG || type == ndn_BinaryXml_EXT) {
         // Start a new level and READ_HEADER_OR_CLOSE again.
         ++self->level;
         startHeader(self);
       }
-      else if (type == ndn_BinaryXML_TAG || type == ndn_BinaryXML_ATTR) {
-        if (type == ndn_BinaryXML_TAG)
+      else if (type == ndn_BinaryXml_TAG || type == ndn_BinaryXml_ATTR) {
+        if (type == ndn_BinaryXml_TAG)
           // Start a new level and read the tag.
           ++self->level;
         // Minimum tag or attribute length is 1.
         self->nBytesToRead = value + 1;
-        self->state = ndn_BinaryXMLStructureDecoder_READ_BYTES;
+        self->state = ndn_BinaryXmlStructureDecoder_READ_BYTES;
         // Binary XML has rules about what must follow an attribute, but we are just scanning.
       }
-      else if (type == ndn_BinaryXML_BLOB || type == ndn_BinaryXML_UDATA) {
+      else if (type == ndn_BinaryXml_BLOB || type == ndn_BinaryXml_UDATA) {
         self->nBytesToRead = value;
-        self->state = ndn_BinaryXMLStructureDecoder_READ_BYTES;
+        self->state = ndn_BinaryXmlStructureDecoder_READ_BYTES;
       }
       else
         return NDN_ERROR_findElementEnd_unrecognized_header_type;
     }  
-    else if (self->state == ndn_BinaryXMLStructureDecoder_READ_BYTES) {
+    else if (self->state == ndn_BinaryXmlStructureDecoder_READ_BYTES) {
       unsigned int nRemainingBytes = inputLength - self->offset;
       if (nRemainingBytes < self->nBytesToRead) {
         // Need more.
diff --git a/ndn-cpp/c/encoding/BinaryXMLStructureDecoder.h b/ndn-cpp/c/encoding/BinaryXMLStructureDecoder.h
index 603ee43..8c561a1 100644
--- a/ndn-cpp/c/encoding/BinaryXMLStructureDecoder.h
+++ b/ndn-cpp/c/encoding/BinaryXMLStructureDecoder.h
@@ -12,7 +12,7 @@
 extern "C" {
 #endif
 
-struct ndn_BinaryXMLStructureDecoder {
+struct ndn_BinaryXmlStructureDecoder {
   int gotElementEnd; /**< boolean */
   unsigned int offset;
   int level;
@@ -25,31 +25,31 @@
 };
 
 enum {
-  ndn_BinaryXMLStructureDecoder_READ_HEADER_OR_CLOSE,
-  ndn_BinaryXMLStructureDecoder_READ_BYTES
+  ndn_BinaryXmlStructureDecoder_READ_HEADER_OR_CLOSE,
+  ndn_BinaryXmlStructureDecoder_READ_BYTES
 };
 
-void ndn_BinaryXMLStructureDecoder_init(struct ndn_BinaryXMLStructureDecoder *self);
+void ndn_BinaryXmlStructureDecoder_init(struct ndn_BinaryXmlStructureDecoder *self);
         
 /**
  * Continue scanning input starting from self->offset to find the element end.  On return, you must check
  *   self->gotElementEnd: If the end of the element which started at offset 0 is found, 
  *   then self->gotElementEnd is 1 and self->offset is the length of the element.  Otherwise, self-forElementEnd is 0 
  *   which means you should read more into input and call again.
- * @param self pointer to the ndn_BinaryXMLStructureDecoder struct
+ * @param self pointer to the ndn_BinaryXmlStructureDecoder struct
  * @param input the input buffer. You have to pass in input each time because the buffer could be reallocated.
  * @param inputLength the number of bytes in input.
  * @return 0 for success, else an error code
  */
-ndn_Error ndn_BinaryXMLStructureDecoder_findElementEnd
-  (struct ndn_BinaryXMLStructureDecoder *self, unsigned char *input, unsigned int inputLength);
+ndn_Error ndn_BinaryXmlStructureDecoder_findElementEnd
+  (struct ndn_BinaryXmlStructureDecoder *self, unsigned char *input, unsigned int inputLength);
 
 /**
  * Set the offset into the input, used for the next read.
- * @param self pointer to the ndn_BinaryXMLStructureDecoder struct
+ * @param self pointer to the ndn_BinaryXmlStructureDecoder struct
  * @param offset the new offset
  */
-static inline void ndn_BinaryXMLStructureDecoder_seek(struct ndn_BinaryXMLStructureDecoder *self, unsigned int offset) 
+static inline void ndn_BinaryXmlStructureDecoder_seek(struct ndn_BinaryXmlStructureDecoder *self, unsigned int offset) 
 {
   self->offset = offset;
 }