complete init draft

Author: pes10k

ad_block_client.cc

@@ -1555,10 +1555,13 @@ char * AdBlockClient::serialize(int *totalSize,
 
 
   SerializedBuffer serializedMatcherBuffer;
-  if (etldMatcher != nullptr) {
-    SerializationResult matcherSerializationResult = etldMatcher->Serialize();
-    serializedMatcherBuffer = matcherSerializationResult.buffer;
+  int serializedMatcherBufSize;
+  if (etldMatcher == nullptr) {
+    etldMatcher = new Matcher();
   }
+  SerializationResult matcherSerializationResult = etldMatcher->Serialize();
+  serializedMatcherBuffer = matcherSerializationResult.buffer;
+  serializedMatcherBufSize = static_cast<int>(serializedMatcherBuffer.size());
 
   // Get the number of bytes that we'll need
   char sz[512];
@@ -1580,7 +1583,7 @@ char * AdBlockClient::serialize(int *totalSize,
       noFingerprintAntiDomainHashSetSize,
       noFingerprintDomainExceptionHashSetSize,
       noFingerprintAntiDomainExceptionHashSetSize,
-      static_cast<int>(serializedMatcherBuffer.size()));
+      serializedMatcherBufSize);
 
   *totalSize += serializeFilters(nullptr, 0, filters, numFilters) +
     serializeFilters(nullptr, 0, exceptionFilters, numExceptionFilters) +
@@ -1609,7 +1612,7 @@ char * AdBlockClient::serialize(int *totalSize,
   *totalSize += noFingerprintAntiDomainHashSetSize;
   *totalSize += noFingerprintDomainExceptionHashSetSize;
   *totalSize += noFingerprintAntiDomainExceptionHashSetSize;
-  *totalSize += serializedMatcherBuffer.size();
+  *totalSize += serializedMatcherBufSize;
 
   // Allocate it
   int pos = 0;
@@ -1689,10 +1692,10 @@ char * AdBlockClient::serialize(int *totalSize,
     delete[] noFingerprintAntiDomainExceptionHashSetBuffer;
   }
 
-  if (serializedMatcherBuffer.size() > 0) {
+  if (serializedMatcherBufSize > 0) {
     memcpy(buffer + pos, serializedMatcherBuffer.c_str(),
-        serializedMatcherBuffer.size());
-    pos += serializedMatcherBuffer.size();
+        serializedMatcherBufSize);
+    pos += serializedMatcherBufSize;
   }
 
   return buffer;
@@ -1746,25 +1749,31 @@ bool AdBlockClient::deserialize(char *buffer) {
       noFingerprintAntiDomainHashSetSize = 0,
       noFingerprintDomainExceptionHashSetSize = 0,
       noFingerprintAntiDomainExceptionHashSetSize = 0,
-      etldMatcherBufferSize = 0;
+      etldMatcherBufSize = 0;
   int pos = 0;
   sscanf(buffer + pos,
       "%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x",
       &numFilters,
-      &numExceptionFilters, &numCosmeticFilters, &numHtmlFilters,
-      &numNoFingerprintFilters, &numNoFingerprintExceptionFilters,
+      &numExceptionFilters,
+      &numCosmeticFilters,
+      &numHtmlFilters,
+      &numNoFingerprintFilters,
+      &numNoFingerprintExceptionFilters,
       &numNoFingerprintDomainOnlyFilters,
       &numNoFingerprintAntiDomainOnlyFilters,
       &numNoFingerprintDomainOnlyExceptionFilters,
       &numNoFingerprintAntiDomainOnlyExceptionFilters,
-      &numHostAnchoredFilters, &numHostAnchoredExceptionFilters,
-      &bloomFilterSize, &exceptionBloomFilterSize,
-      &hostAnchoredHashSetSize, &hostAnchoredExceptionHashSetSize,
+      &numHostAnchoredFilters,
+      &numHostAnchoredExceptionFilters,
+      &bloomFilterSize,
+      &exceptionBloomFilterSize,
+      &hostAnchoredHashSetSize,
+      &hostAnchoredExceptionHashSetSize,
       &noFingerprintDomainHashSetSize,
       &noFingerprintAntiDomainHashSetSize,
       &noFingerprintDomainExceptionHashSetSize,
       &noFingerprintAntiDomainExceptionHashSetSize,
-      &etldMatcherBufferSize);
+      &etldMatcherBufSize);
   pos += static_cast<int>(strlen(buffer + pos)) + 1;
 
   filters = new Filter[numFilters];
@@ -1813,48 +1822,49 @@ bool AdBlockClient::deserialize(char *buffer) {
   pos += exceptionBloomFilterSize;
   if (!initHashSet(&hostAnchoredHashSet,
         buffer + pos, hostAnchoredHashSetSize)) {
-      return false;
+    return false;
   }
   pos += hostAnchoredHashSetSize;
   if (!initHashSet(&hostAnchoredExceptionHashSet,
         buffer + pos, hostAnchoredExceptionHashSetSize)) {
-      return false;
+    return false;
   }
   pos += hostAnchoredExceptionHashSetSize;
 
 
   if (!initHashSet(&noFingerprintDomainHashSet,
         buffer + pos, noFingerprintDomainHashSetSize)) {
-      return false;
+    return false;
   }
   pos += noFingerprintDomainHashSetSize;
 
   if (!initHashSet(&noFingerprintAntiDomainHashSet,
         buffer + pos, noFingerprintAntiDomainHashSetSize)) {
-      return false;
+    return false;
   }
   pos += noFingerprintAntiDomainHashSetSize;
 
   if (!initHashSet(&noFingerprintDomainExceptionHashSet,
         buffer + pos, noFingerprintDomainExceptionHashSetSize)) {
-      return false;
+    return false;
   }
   pos += noFingerprintDomainExceptionHashSetSize;
 
   if (!initHashSet(&noFingerprintAntiDomainExceptionHashSet,
         buffer + pos, noFingerprintAntiDomainExceptionHashSetSize)) {
-      return false;
+    return false;
   }
   pos += noFingerprintAntiDomainExceptionHashSetSize;
 
   if (etldMatcher != nullptr) {
     delete etldMatcher;
   }
-  if (etldMatcherBufferSize == 0) {
+
+  if (etldMatcherBufSize == 0) {
     etldMatcher = new Matcher();
   } else {
     SerializedBuffer serializedmatcherBuffer = std::string(
-      buffer + pos, etldMatcherBufferSize);
+      buffer + pos, etldMatcherBufSize);
     Matcher newMatcher = matcher_from_serialization(serializedmatcherBuffer);
     etldMatcher = new Matcher(newMatcher);
   }

etld/matcher.h

@@ -33,6 +33,14 @@ class Matcher {
   void ConsumeParseResult(const PublicSuffixParseResult &result);
   DomainInfo Match(const Domain &domain) const;
 
+  size_t NumRules() const {
+    return rules_.Rules().size();
+  }
+
+  size_t NumExceptionRules() const {
+    return exception_rules_.Rules().size();
+  }
+
  private:
   DomainInfo BuildDomainInfo(const PublicSuffixRule &rule,
     const Domain &domain) const;

etld/public_suffix_rule_set.cc

@@ -65,7 +65,7 @@ SerializationResult PublicSuffixRuleSet::Serialize() const {
   const size_t buffer_size = body_start + body_len + 1;
   char buffer[buffer_size];
 
-  int written = snprintf(
+  snprintf(
     buffer,
     buffer_size,
     "%s:%s",

etld/serialization.h

@@ -12,7 +12,6 @@
 namespace brave_etld {
 
 typedef std::string SerializedBuffer;
-
 typedef std::vector<SerializedBuffer> SerializedChildBuffers;
 
 struct SerializedBufferInfo {

test/etld_serialization_test.cc

@@ -10,6 +10,7 @@
 #include <fstream>
 #include "./CppUnitLite/TestHarness.h"
 #include "./CppUnitLite/Test.h"
+#include "./ad_block_client.h"
 #include "./etld/types.h"
 #include "./etld/matcher.h"
 #include "./etld/parser.h"
@@ -27,6 +28,7 @@ using brave_etld::SerializationResult;
 using brave_etld::rule_from_serialization;
 using brave_etld::rule_set_from_serialization;
 using brave_etld::matcher_from_serialization;
+using brave_etld::SerializedBuffer;
 
 bool testSerializeRule(const string &rule_text) {
   PublicSuffixRule rule(rule_text);
@@ -69,4 +71,100 @@ TEST(eTLDSerializationMatcher, basic) {
   CHECK(testSerializeMatcher("!one.com"));
   CHECK(testSerializeMatcher("!one.com\n*.two.com"));
   CHECK(testSerializeMatcher("!one.com\n*.two.com\nthree.com"));
+}
+
+bool testDeserializationCorrectness(const SerializedBuffer &rule_text,
+    int num_rules, int num_exception_rules) {
+  Matcher matcher = matcher_from_serialization(rule_text);
+  int num_matcher_rules = static_cast<int>(matcher.NumRules());
+  if (num_matcher_rules != num_rules) {
+    std::cout << "Expected " << num_rules << " rules from buffer, but received "
+              << num_matcher_rules << " rules." << std::endl;
+    return false;
+  }
+
+  int num_matcher_except_rules = static_cast<int>(matcher.NumExceptionRules());
+  if (num_matcher_except_rules != num_exception_rules) {
+    std::cout << "Expected " << num_rules << " exception rules from buffer, "
+              << "but received " <<  num_exception_rules << " rules."
+              << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
+// TEST(eTLDDeserializationTests, basic) {
+//   CHECK(testDeserializationCorrectness(
+//     "47:42:29:ff||not-matching-anything.com8:fftrees^0:", 2, 0));
+// }
+
+bool testSerializationCorrectness(const string &rule_text,
+    const SerializedBuffer &serialized) {
+  Matcher matcher(rule_text);
+  SerializationResult result = matcher.Serialize();
+  return result.buffer.compare(serialized) == 0;
+}
+
+// TEST(eTLDSerializationTests, basic) {
+//   const string rules = "||s3.amazonaws.com^$third-party\n"
+//                        "||not-matching-anything.com\n"
+//                        "trees^";
+//   CHECK(testSerializationCorrectness(rules, ));
+// }
+
+bool testMatcherSerializationTransitivity(const string &public_suffix_rules) {
+  Matcher orig(public_suffix_rules);
+  SerializationResult res = orig.Serialize();
+
+  Matcher second = matcher_from_serialization(res.buffer);
+  SerializationResult res2 = second.Serialize();
+
+  if (res2.buffer.compare(res.buffer) != 0) {
+    std::cout << "The serialized buffer of the initial Matcher does not match "
+              << "the serialized of the second, buffer initialized buffer."
+              << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
+bool testAdBlockClientSerializationTransitivity(const string &filter_rules,
+    const string &public_suffix_rules) {
+  AdBlockClient client;
+  client.parse(filter_rules.c_str());
+  client.parsePublicSuffixRules(public_suffix_rules.c_str());
+  
+  int size;
+  char* buffer = client.serialize(&size);
+
+  AdBlockClient client2;
+  client2.deserialize(buffer);
+  int size2;
+  char* buffer2 = client2.serialize(&size2);
+
+  if (size != size2) {
+    std::cout << "The size of the serialized buffers of the first and second "
+              << "client do not match." << std::endl;
+    return false;
+  }
+
+  if (strncmp(buffer, buffer2, size) != 0) {
+    std::cout << "The serialized buffers of the first and second client do "
+              << "not have the same contents." << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
+TEST(eTLDSerializationTransitivity, basic) {
+  std::ifstream ifs("./test/data/public_suffix_list_short.txt");
+  const string public_suffix_rules((std::istreambuf_iterator<char>(ifs)),
+                                   (std::istreambuf_iterator<char>()));
+  const string filer_rules = "||not-matching-anything.com\ntrees^";
+  CHECK(testMatcherSerializationTransitivity(public_suffix_rules));
+  CHECK(testAdBlockClientSerializationTransitivity(
+    filer_rules, public_suffix_rules));
 }