capnproto

afl-testcase.c++ (4814B)

---

 // Copyright (c) 2017 Cloudflare, Inc. and contributors
 // Licensed under the MIT License:
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in
 // all copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
 #include "test-util.h"
 #include <kj/main.h>
 #include "serialize.h"
 #include <capnp/test.capnp.h>
 #include <unistd.h>
 
 namespace capnp {
 namespace _ {
 namespace {
 
 class AflTestMain {
 public:
   explicit AflTestMain(kj::ProcessContext& context)
       : context(context) {}
 
   kj::MainFunc getMain() {
     return kj::MainBuilder(context, "(unknown version)",
         "American Fuzzy Lop test case. Pass input on stdin. Expects a binary "
         "message of type TestAllTypes.")
         .addOption({"lists"}, KJ_BIND_METHOD(*this, runLists),
             "Expect a message of type TestLists instead of TestAllTypes.")
         .addOption({"canonicalize"}, KJ_BIND_METHOD(*this, canonicalize),
             "Test canonicalization code.")
         .callAfterParsing(KJ_BIND_METHOD(*this, run))
         .build();
   }
 
   kj::MainBuilder::Validity run() {
     capnp::StreamFdMessageReader reader(STDIN_FILENO);
     KJ_IF_MAYBE(e, kj::runCatchingExceptions([&]() {
       checkTestMessage(reader.getRoot<TestAllTypes>());
     })) {
       KJ_LOG(ERROR, "threw");
     }
     KJ_IF_MAYBE(e, kj::runCatchingExceptions([&]() {
       checkDynamicTestMessage(reader.getRoot<DynamicStruct>(Schema::from<TestAllTypes>()));
     })) {
       KJ_LOG(ERROR, "dynamic threw");
     }
     KJ_IF_MAYBE(e, kj::runCatchingExceptions([&]() {
       kj::str(reader.getRoot<TestAllTypes>());
     })) {
       KJ_LOG(ERROR, "str threw");
     }
     return true;
   }
 
   kj::MainBuilder::Validity runLists() {
     capnp::StreamFdMessageReader reader(STDIN_FILENO);
     KJ_IF_MAYBE(e, kj::runCatchingExceptions([&]() {
       kj::str(reader.getRoot<test::TestLists>());
     })) {
       KJ_LOG(ERROR, "threw");
     }
     return true;
   }
 
   kj::MainBuilder::Validity canonicalize() {
     // (Test case contributed by David Renshaw.)
 
     kj::Array<capnp::word> canonical;
     bool equal = false;
     KJ_IF_MAYBE(e, kj::runCatchingExceptions([&]() {
       capnp::ReaderOptions options;
 
       // The default traversal limit of 8 * 1024 * 1024 causes
       // AFL to think that it has found "hang" bugs.
       options.traversalLimitInWords = 8 * 1024;
 
       capnp::StreamFdMessageReader message(0, options); // read from stdin
       TestAllTypes::Reader myStruct = message.getRoot<TestAllTypes>();
       canonical = capnp::canonicalize(myStruct);
 
       kj::ArrayPtr<const capnp::word> segments[1] = {canonical.asPtr()};
       capnp::SegmentArrayMessageReader reader(kj::arrayPtr(segments, 1));
 
       auto originalAny = message.getRoot<capnp::AnyPointer>();
 
       // Discard cases where the original message is null.
       KJ_ASSERT(!originalAny.isNull());
 
       equal = originalAny == reader.getRoot<capnp::AnyPointer>();
     })) {
       // Probably some kind of decoding exception.
       KJ_LOG(ERROR, "threw");
       context.exit();
     }
 
     KJ_ASSERT(equal);
 
     kj::ArrayPtr<const capnp::word> segments[1] = {canonical.asPtr()};
     capnp::SegmentArrayMessageReader reader(kj::arrayPtr(segments, 1));
     KJ_ASSERT(reader.isCanonical());
 
     kj::Array<capnp::word> canonical2;
     {
       capnp::ReaderOptions options;
       options.traversalLimitInWords = 8 * 1024;
 
       TestAllTypes::Reader myStruct = reader.getRoot<TestAllTypes>();
       canonical2 = capnp::canonicalize(myStruct);
     }
 
     KJ_ASSERT(canonical.size() == canonical2.size());
     auto b1 = canonical.asBytes();
     auto b2 = canonical2.asBytes();
     for (int idx = 0; idx < b1.size(); ++idx) {
       KJ_ASSERT(b1[idx] == b2[idx], idx, b1.size());
     }
 
     return true;
   }
 
 private:
   kj::ProcessContext& context;
 };
 
 }  // namespace
 }  // namespace _
 }  // namespace capnp
 
 KJ_MAIN(capnp::_::AflTestMain);