diff --git a/ndn-cpp/c/interest.c b/ndn-cpp/c/interest.c
index 0e32368..44c3ff6 100644
--- a/ndn-cpp/c/interest.c
+++ b/ndn-cpp/c/interest.c
@@ -9,13 +9,13 @@
 
 int ndn_Exclude_compareComponents(struct ndn_NameComponent *component1, struct ndn_NameComponent *component2)
 {
-  if (component1->valueLength < component2->valueLength)
+  if (component1->value.length < component2->value.length)
     return -1;
-  if (component1->valueLength > component2->valueLength)
+  if (component1->value.length > component2->value.length)
     return 1;
 
   // The components are equal length.  Just do a byte compare.  
-  return ndn_memcmp(component1->value, component2->value, component1->valueLength);
+  return ndn_memcmp(component1->value.value, component2->value.value, component1->value.length);
 }
 
 int ndn_Exclude_matches(struct ndn_Exclude *self, struct ndn_NameComponent *component)
