cannam@147: // Copyright (c) 2013-2016 Sandstorm Development Group, Inc. and contributors cannam@147: // Licensed under the MIT License: cannam@147: // cannam@147: // Permission is hereby granted, free of charge, to any person obtaining a copy cannam@147: // of this software and associated documentation files (the "Software"), to deal cannam@147: // in the Software without restriction, including without limitation the rights cannam@147: // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell cannam@147: // copies of the Software, and to permit persons to whom the Software is cannam@147: // furnished to do so, subject to the following conditions: cannam@147: // cannam@147: // The above copyright notice and this permission notice shall be included in cannam@147: // all copies or substantial portions of the Software. cannam@147: // cannam@147: // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR cannam@147: // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, cannam@147: // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE cannam@147: // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER cannam@147: // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, cannam@147: // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN cannam@147: // THE SOFTWARE. cannam@147: cannam@147: #include cannam@147: #include cannam@147: #include cannam@147: #include cannam@147: #include "common.h" cannam@147: #include "layout.h" cannam@147: #include "any.h" cannam@147: cannam@147: #ifndef CAPNP_MESSAGE_H_ cannam@147: #define CAPNP_MESSAGE_H_ cannam@147: cannam@147: #if defined(__GNUC__) && !defined(CAPNP_HEADER_WARNINGS) cannam@147: #pragma GCC system_header cannam@147: #endif cannam@147: cannam@147: namespace capnp { cannam@147: cannam@147: namespace _ { // private cannam@147: class ReaderArena; cannam@147: class BuilderArena; cannam@147: } cannam@147: cannam@147: class StructSchema; cannam@147: class Orphanage; cannam@147: template cannam@147: class Orphan; cannam@147: cannam@147: // ======================================================================================= cannam@147: cannam@147: struct ReaderOptions { cannam@147: // Options controlling how data is read. cannam@147: cannam@147: uint64_t traversalLimitInWords = 8 * 1024 * 1024; cannam@147: // Limits how many total words of data are allowed to be traversed. Traversal is counted when cannam@147: // a new struct or list builder is obtained, e.g. from a get() accessor. This means that calling cannam@147: // the getter for the same sub-struct multiple times will cause it to be double-counted. Once cannam@147: // the traversal limit is reached, an error will be reported. cannam@147: // cannam@147: // This limit exists for security reasons. It is possible for an attacker to construct a message cannam@147: // in which multiple pointers point at the same location. This is technically invalid, but hard cannam@147: // to detect. Using such a message, an attacker could cause a message which is small on the wire cannam@147: // to appear much larger when actually traversed, possibly exhausting server resources leading to cannam@147: // denial-of-service. cannam@147: // cannam@147: // It makes sense to set a traversal limit that is much larger than the underlying message. cannam@147: // Together with sensible coding practices (e.g. trying to avoid calling sub-object getters cannam@147: // multiple times, which is expensive anyway), this should provide adequate protection without cannam@147: // inconvenience. cannam@147: // cannam@147: // The default limit is 64 MiB. This may or may not be a sensible number for any given use case, cannam@147: // but probably at least prevents easy exploitation while also avoiding causing problems in most cannam@147: // typical cases. cannam@147: cannam@147: int nestingLimit = 64; cannam@147: // Limits how deeply-nested a message structure can be, e.g. structs containing other structs or cannam@147: // lists of structs. cannam@147: // cannam@147: // Like the traversal limit, this limit exists for security reasons. Since it is common to use cannam@147: // recursive code to traverse recursive data structures, an attacker could easily cause a stack cannam@147: // overflow by sending a very-deeply-nested (or even cyclic) message, without the message even cannam@147: // being very large. The default limit of 64 is probably low enough to prevent any chance of cannam@147: // stack overflow, yet high enough that it is never a problem in practice. cannam@147: }; cannam@147: cannam@147: class MessageReader { cannam@147: // Abstract interface for an object used to read a Cap'n Proto message. Subclasses of cannam@147: // MessageReader are responsible for reading the raw, flat message content. Callers should cannam@147: // usually call `messageReader.getRoot()` to get a `MyStructType::Reader` cannam@147: // representing the root of the message, then use that to traverse the message content. cannam@147: // cannam@147: // Some common subclasses of `MessageReader` include `SegmentArrayMessageReader`, whose cannam@147: // constructor accepts pointers to the raw data, and `StreamFdMessageReader` (from cannam@147: // `serialize.h`), which reads the message from a file descriptor. One might implement other cannam@147: // subclasses to handle things like reading from shared memory segments, mmap()ed files, etc. cannam@147: cannam@147: public: cannam@147: MessageReader(ReaderOptions options); cannam@147: // It is suggested that subclasses take ReaderOptions as a constructor parameter, but give it a cannam@147: // default value of "ReaderOptions()". The base class constructor doesn't have a default value cannam@147: // in order to remind subclasses that they really need to give the user a way to provide this. cannam@147: cannam@147: virtual ~MessageReader() noexcept(false); cannam@147: cannam@147: virtual kj::ArrayPtr getSegment(uint id) = 0; cannam@147: // Gets the segment with the given ID, or returns null if no such segment exists. This method cannam@147: // will be called at most once for each segment ID. cannam@147: cannam@147: inline const ReaderOptions& getOptions(); cannam@147: // Get the options passed to the constructor. cannam@147: cannam@147: template cannam@147: typename RootType::Reader getRoot(); cannam@147: // Get the root struct of the message, interpreting it as the given struct type. cannam@147: cannam@147: template cannam@147: typename RootType::Reader getRoot(SchemaType schema); cannam@147: // Dynamically interpret the root struct of the message using the given schema (a StructSchema). cannam@147: // RootType in this case must be DynamicStruct, and you must #include to cannam@147: // use this. cannam@147: cannam@147: bool isCanonical(); cannam@147: // Returns whether the message encoded in the reader is in canonical form. cannam@147: cannam@147: private: cannam@147: ReaderOptions options; cannam@147: cannam@147: // Space in which we can construct a ReaderArena. We don't use ReaderArena directly here cannam@147: // because we don't want clients to have to #include arena.h, which itself includes a bunch of cannam@147: // big STL headers. We don't use a pointer to a ReaderArena because that would require an cannam@147: // extra malloc on every message which could be expensive when processing small messages. cannam@147: void* arenaSpace[15 + sizeof(kj::MutexGuarded) / sizeof(void*)]; cannam@147: bool allocatedArena; cannam@147: cannam@147: _::ReaderArena* arena() { return reinterpret_cast<_::ReaderArena*>(arenaSpace); } cannam@147: AnyPointer::Reader getRootInternal(); cannam@147: }; cannam@147: cannam@147: class MessageBuilder { cannam@147: // Abstract interface for an object used to allocate and build a message. Subclasses of cannam@147: // MessageBuilder are responsible for allocating the space in which the message will be written. cannam@147: // The most common subclass is `MallocMessageBuilder`, but other subclasses may be used to do cannam@147: // tricky things like allocate messages in shared memory or mmap()ed files. cannam@147: // cannam@147: // Creating a new message ususually means allocating a new MessageBuilder (ideally on the stack) cannam@147: // and then calling `messageBuilder.initRoot()` to get a `MyStructType::Builder`. cannam@147: // That, in turn, can be used to fill in the message content. When done, you can call cannam@147: // `messageBuilder.getSegmentsForOutput()` to get a list of flat data arrays containing the cannam@147: // message. cannam@147: cannam@147: public: cannam@147: MessageBuilder(); cannam@147: virtual ~MessageBuilder() noexcept(false); cannam@147: KJ_DISALLOW_COPY(MessageBuilder); cannam@147: cannam@147: struct SegmentInit { cannam@147: kj::ArrayPtr space; cannam@147: cannam@147: size_t wordsUsed; cannam@147: // Number of words in `space` which are used; the rest are free space in which additional cannam@147: // objects may be allocated. cannam@147: }; cannam@147: cannam@147: explicit MessageBuilder(kj::ArrayPtr segments); cannam@147: // Create a MessageBuilder backed by existing memory. This is an advanced interface that most cannam@147: // people should not use. THIS METHOD IS INSECURE; see below. cannam@147: // cannam@147: // This allows a MessageBuilder to be constructed to modify an in-memory message without first cannam@147: // making a copy of the content. This is especially useful in conjunction with mmap(). cannam@147: // cannam@147: // The contents of each segment must outlive the MessageBuilder, but the SegmentInit array itself cannam@147: // only need outlive the constructor. cannam@147: // cannam@147: // SECURITY: Do not use this in conjunction with untrusted data. This constructor assumes that cannam@147: // the input message is valid. This constructor is designed to be used with data you control, cannam@147: // e.g. an mmap'd file which is owned and accessed by only one program. When reading data you cannam@147: // do not trust, you *must* load it into a Reader and then copy into a Builder as a means of cannam@147: // validating the content. cannam@147: // cannam@147: // WARNING: It is NOT safe to initialize a MessageBuilder in this way from memory that is cannam@147: // currently in use by another MessageBuilder or MessageReader. Other readers/builders will cannam@147: // not observe changes to the segment sizes nor newly-allocated segments caused by allocating cannam@147: // new objects in this message. cannam@147: cannam@147: virtual kj::ArrayPtr allocateSegment(uint minimumSize) = 0; cannam@147: // Allocates an array of at least the given number of words, throwing an exception or crashing if cannam@147: // this is not possible. It is expected that this method will usually return more space than cannam@147: // requested, and the caller should use that extra space as much as possible before allocating cannam@147: // more. The returned space remains valid at least until the MessageBuilder is destroyed. cannam@147: // cannam@147: // Cap'n Proto will only call this once at a time, so the subclass need not worry about cannam@147: // thread-safety. cannam@147: cannam@147: template cannam@147: typename RootType::Builder initRoot(); cannam@147: // Initialize the root struct of the message as the given struct type. cannam@147: cannam@147: template cannam@147: void setRoot(Reader&& value); cannam@147: // Set the root struct to a deep copy of the given struct. cannam@147: cannam@147: template cannam@147: typename RootType::Builder getRoot(); cannam@147: // Get the root struct of the message, interpreting it as the given struct type. cannam@147: cannam@147: template cannam@147: typename RootType::Builder getRoot(SchemaType schema); cannam@147: // Dynamically interpret the root struct of the message using the given schema (a StructSchema). cannam@147: // RootType in this case must be DynamicStruct, and you must #include to cannam@147: // use this. cannam@147: cannam@147: template cannam@147: typename RootType::Builder initRoot(SchemaType schema); cannam@147: // Dynamically init the root struct of the message using the given schema (a StructSchema). cannam@147: // RootType in this case must be DynamicStruct, and you must #include to cannam@147: // use this. cannam@147: cannam@147: template cannam@147: void adoptRoot(Orphan&& orphan); cannam@147: // Like setRoot() but adopts the orphan without copying. cannam@147: cannam@147: kj::ArrayPtr> getSegmentsForOutput(); cannam@147: // Get the raw data that makes up the message. cannam@147: cannam@147: Orphanage getOrphanage(); cannam@147: cannam@147: bool isCanonical(); cannam@147: // Check whether the message builder is in canonical form cannam@147: cannam@147: private: cannam@147: void* arenaSpace[22]; cannam@147: // Space in which we can construct a BuilderArena. We don't use BuilderArena directly here cannam@147: // because we don't want clients to have to #include arena.h, which itself includes a bunch of cannam@147: // big STL headers. We don't use a pointer to a BuilderArena because that would require an cannam@147: // extra malloc on every message which could be expensive when processing small messages. cannam@147: cannam@147: bool allocatedArena = false; cannam@147: // We have to initialize the arena lazily because when we do so we want to allocate the root cannam@147: // pointer immediately, and this will allocate a segment, which requires a virtual function cannam@147: // call on the MessageBuilder. We can't do such a call in the constructor since the subclass cannam@147: // isn't constructed yet. This is kind of annoying because it means that getOrphanage() is cannam@147: // not thread-safe, but that shouldn't be a huge deal... cannam@147: cannam@147: _::BuilderArena* arena() { return reinterpret_cast<_::BuilderArena*>(arenaSpace); } cannam@147: _::SegmentBuilder* getRootSegment(); cannam@147: AnyPointer::Builder getRootInternal(); cannam@147: }; cannam@147: cannam@147: template cannam@147: typename RootType::Reader readMessageUnchecked(const word* data); cannam@147: // IF THE INPUT IS INVALID, THIS MAY CRASH, CORRUPT MEMORY, CREATE A SECURITY HOLE IN YOUR APP, cannam@147: // MURDER YOUR FIRST-BORN CHILD, AND/OR BRING ABOUT ETERNAL DAMNATION ON ALL OF HUMANITY. DO NOT cannam@147: // USE UNLESS YOU UNDERSTAND THE CONSEQUENCES. cannam@147: // cannam@147: // Given a pointer to a known-valid message located in a single contiguous memory segment, cannam@147: // returns a reader for that message. No bounds-checking will be done while traversing this cannam@147: // message. Use this only if you have already verified that all pointers are valid and in-bounds, cannam@147: // and there are no far pointers in the message. cannam@147: // cannam@147: // To create a message that can be passed to this function, build a message using a MallocAllocator cannam@147: // whose preferred segment size is larger than the message size. This guarantees that the message cannam@147: // will be allocated as a single segment, meaning getSegmentsForOutput() returns a single word cannam@147: // array. That word array is your message; you may pass a pointer to its first word into cannam@147: // readMessageUnchecked() to read the message. cannam@147: // cannam@147: // This can be particularly handy for embedding messages in generated code: you can cannam@147: // embed the raw bytes (using AlignedData) then make a Reader for it using this. This is the way cannam@147: // default values are embedded in code generated by the Cap'n Proto compiler. E.g., if you have cannam@147: // a message MyMessage, you can read its default value like so: cannam@147: // MyMessage::Reader reader = Message::readMessageUnchecked(MyMessage::DEFAULT.words); cannam@147: // cannam@147: // To sanitize a message from an untrusted source such that it can be safely passed to cannam@147: // readMessageUnchecked(), use copyToUnchecked(). cannam@147: cannam@147: template cannam@147: void copyToUnchecked(Reader&& reader, kj::ArrayPtr uncheckedBuffer); cannam@147: // Copy the content of the given reader into the given buffer, such that it can safely be passed to cannam@147: // readMessageUnchecked(). The buffer's size must be exactly reader.totalSizeInWords() + 1, cannam@147: // otherwise an exception will be thrown. The buffer must be zero'd before calling. cannam@147: cannam@147: template cannam@147: typename RootType::Reader readDataStruct(kj::ArrayPtr data); cannam@147: // Interprets the given data as a single, data-only struct. Only primitive fields (booleans, cannam@147: // numbers, and enums) will be readable; all pointers will be null. This is useful if you want cannam@147: // to use Cap'n Proto as a language/platform-neutral way to pack some bits. cannam@147: // cannam@147: // The input is a word array rather than a byte array to enforce alignment. If you have a byte cannam@147: // array which you know is word-aligned (or if your platform supports unaligned reads and you don't cannam@147: // mind the performance penalty), then you can use `reinterpret_cast` to convert a byte array into cannam@147: // a word array: cannam@147: // cannam@147: // kj::arrayPtr(reinterpret_cast(bytes.begin()), cannam@147: // reinterpret_cast(bytes.end())) cannam@147: cannam@147: template cannam@147: typename kj::ArrayPtr writeDataStruct(BuilderType builder); cannam@147: // Given a struct builder, get the underlying data section as a word array, suitable for passing cannam@147: // to `readDataStruct()`. cannam@147: // cannam@147: // Note that you may call `.toBytes()` on the returned value to convert to `ArrayPtr`. cannam@147: cannam@147: template cannam@147: static typename Type::Reader defaultValue(); cannam@147: // Get a default instance of the given struct or list type. cannam@147: // cannam@147: // TODO(cleanup): Find a better home for this function? cannam@147: cannam@147: // ======================================================================================= cannam@147: cannam@147: class SegmentArrayMessageReader: public MessageReader { cannam@147: // A simple MessageReader that reads from an array of word arrays representing all segments. cannam@147: // In particular you can read directly from the output of MessageBuilder::getSegmentsForOutput() cannam@147: // (although it would probably make more sense to call builder.getRoot().asReader() in that case). cannam@147: cannam@147: public: cannam@147: SegmentArrayMessageReader(kj::ArrayPtr> segments, cannam@147: ReaderOptions options = ReaderOptions()); cannam@147: // Creates a message pointing at the given segment array, without taking ownership of the cannam@147: // segments. All arrays passed in must remain valid until the MessageReader is destroyed. cannam@147: cannam@147: KJ_DISALLOW_COPY(SegmentArrayMessageReader); cannam@147: ~SegmentArrayMessageReader() noexcept(false); cannam@147: cannam@147: virtual kj::ArrayPtr getSegment(uint id) override; cannam@147: cannam@147: private: cannam@147: kj::ArrayPtr> segments; cannam@147: }; cannam@147: cannam@147: enum class AllocationStrategy: uint8_t { cannam@147: FIXED_SIZE, cannam@147: // The builder will prefer to allocate the same amount of space for each segment with no cannam@147: // heuristic growth. It will still allocate larger segments when the preferred size is too small cannam@147: // for some single object. This mode is generally not recommended, but can be particularly useful cannam@147: // for testing in order to force a message to allocate a predictable number of segments. Note cannam@147: // that you can force every single object in the message to be located in a separate segment by cannam@147: // using this mode with firstSegmentWords = 0. cannam@147: cannam@147: GROW_HEURISTICALLY cannam@147: // The builder will heuristically decide how much space to allocate for each segment. Each cannam@147: // allocated segment will be progressively larger than the previous segments on the assumption cannam@147: // that message sizes are exponentially distributed. The total number of segments that will be cannam@147: // allocated for a message of size n is O(log n). cannam@147: }; cannam@147: cannam@147: constexpr uint SUGGESTED_FIRST_SEGMENT_WORDS = 1024; cannam@147: constexpr AllocationStrategy SUGGESTED_ALLOCATION_STRATEGY = AllocationStrategy::GROW_HEURISTICALLY; cannam@147: cannam@147: class MallocMessageBuilder: public MessageBuilder { cannam@147: // A simple MessageBuilder that uses malloc() (actually, calloc()) to allocate segments. This cannam@147: // implementation should be reasonable for any case that doesn't require writing the message to cannam@147: // a specific location in memory. cannam@147: cannam@147: public: cannam@147: explicit MallocMessageBuilder(uint firstSegmentWords = SUGGESTED_FIRST_SEGMENT_WORDS, cannam@147: AllocationStrategy allocationStrategy = SUGGESTED_ALLOCATION_STRATEGY); cannam@147: // Creates a BuilderContext which allocates at least the given number of words for the first cannam@147: // segment, and then uses the given strategy to decide how much to allocate for subsequent cannam@147: // segments. When choosing a value for firstSegmentWords, consider that: cannam@147: // 1) Reading and writing messages gets slower when multiple segments are involved, so it's good cannam@147: // if most messages fit in a single segment. cannam@147: // 2) Unused bytes will not be written to the wire, so generally it is not a big deal to allocate cannam@147: // more space than you need. It only becomes problematic if you are allocating many messages cannam@147: // in parallel and thus use lots of memory, or if you allocate so much extra space that just cannam@147: // zeroing it out becomes a bottleneck. cannam@147: // The defaults have been chosen to be reasonable for most people, so don't change them unless you cannam@147: // have reason to believe you need to. cannam@147: cannam@147: explicit MallocMessageBuilder(kj::ArrayPtr firstSegment, cannam@147: AllocationStrategy allocationStrategy = SUGGESTED_ALLOCATION_STRATEGY); cannam@147: // This version always returns the given array for the first segment, and then proceeds with the cannam@147: // allocation strategy. This is useful for optimization when building lots of small messages in cannam@147: // a tight loop: you can reuse the space for the first segment. cannam@147: // cannam@147: // firstSegment MUST be zero-initialized. MallocMessageBuilder's destructor will write new zeros cannam@147: // over any space that was used so that it can be reused. cannam@147: cannam@147: KJ_DISALLOW_COPY(MallocMessageBuilder); cannam@147: virtual ~MallocMessageBuilder() noexcept(false); cannam@147: cannam@147: virtual kj::ArrayPtr allocateSegment(uint minimumSize) override; cannam@147: cannam@147: private: cannam@147: uint nextSize; cannam@147: AllocationStrategy allocationStrategy; cannam@147: cannam@147: bool ownFirstSegment; cannam@147: bool returnedFirstSegment; cannam@147: cannam@147: void* firstSegment; cannam@147: cannam@147: struct MoreSegments; cannam@147: kj::Maybe> moreSegments; cannam@147: }; cannam@147: cannam@147: class FlatMessageBuilder: public MessageBuilder { cannam@147: // THIS IS NOT THE CLASS YOU'RE LOOKING FOR. cannam@147: // cannam@147: // If you want to write a message into already-existing scratch space, use `MallocMessageBuilder` cannam@147: // and pass the scratch space to its constructor. It will then only fall back to malloc() if cannam@147: // the scratch space is not large enough. cannam@147: // cannam@147: // Do NOT use this class unless you really know what you're doing. This class is problematic cannam@147: // because it requires advance knowledge of the size of your message, which is usually impossible cannam@147: // to determine without actually building the message. The class was created primarily to cannam@147: // implement `copyToUnchecked()`, which itself exists only to support other internal parts of cannam@147: // the Cap'n Proto implementation. cannam@147: cannam@147: public: cannam@147: explicit FlatMessageBuilder(kj::ArrayPtr array); cannam@147: KJ_DISALLOW_COPY(FlatMessageBuilder); cannam@147: virtual ~FlatMessageBuilder() noexcept(false); cannam@147: cannam@147: void requireFilled(); cannam@147: // Throws an exception if the flat array is not exactly full. cannam@147: cannam@147: virtual kj::ArrayPtr allocateSegment(uint minimumSize) override; cannam@147: cannam@147: private: cannam@147: kj::ArrayPtr array; cannam@147: bool allocated; cannam@147: }; cannam@147: cannam@147: // ======================================================================================= cannam@147: // implementation details cannam@147: cannam@147: inline const ReaderOptions& MessageReader::getOptions() { cannam@147: return options; cannam@147: } cannam@147: cannam@147: template cannam@147: inline typename RootType::Reader MessageReader::getRoot() { cannam@147: return getRootInternal().getAs(); cannam@147: } cannam@147: cannam@147: template cannam@147: inline typename RootType::Builder MessageBuilder::initRoot() { cannam@147: return getRootInternal().initAs(); cannam@147: } cannam@147: cannam@147: template cannam@147: inline void MessageBuilder::setRoot(Reader&& value) { cannam@147: getRootInternal().setAs>(value); cannam@147: } cannam@147: cannam@147: template cannam@147: inline typename RootType::Builder MessageBuilder::getRoot() { cannam@147: return getRootInternal().getAs(); cannam@147: } cannam@147: cannam@147: template cannam@147: void MessageBuilder::adoptRoot(Orphan&& orphan) { cannam@147: return getRootInternal().adopt(kj::mv(orphan)); cannam@147: } cannam@147: cannam@147: template cannam@147: typename RootType::Reader MessageReader::getRoot(SchemaType schema) { cannam@147: return getRootInternal().getAs(schema); cannam@147: } cannam@147: cannam@147: template cannam@147: typename RootType::Builder MessageBuilder::getRoot(SchemaType schema) { cannam@147: return getRootInternal().getAs(schema); cannam@147: } cannam@147: cannam@147: template cannam@147: typename RootType::Builder MessageBuilder::initRoot(SchemaType schema) { cannam@147: return getRootInternal().initAs(schema); cannam@147: } cannam@147: cannam@147: template cannam@147: typename RootType::Reader readMessageUnchecked(const word* data) { cannam@147: return AnyPointer::Reader(_::PointerReader::getRootUnchecked(data)).getAs(); cannam@147: } cannam@147: cannam@147: template cannam@147: void copyToUnchecked(Reader&& reader, kj::ArrayPtr uncheckedBuffer) { cannam@147: FlatMessageBuilder builder(uncheckedBuffer); cannam@147: builder.setRoot(kj::fwd(reader)); cannam@147: builder.requireFilled(); cannam@147: } cannam@147: cannam@147: template cannam@147: typename RootType::Reader readDataStruct(kj::ArrayPtr data) { cannam@147: return typename RootType::Reader(_::StructReader(data)); cannam@147: } cannam@147: cannam@147: template cannam@147: typename kj::ArrayPtr writeDataStruct(BuilderType builder) { cannam@147: auto bytes = _::PointerHelpers>::getInternalBuilder(kj::mv(builder)) cannam@147: .getDataSectionAsBlob(); cannam@147: return kj::arrayPtr(reinterpret_cast(bytes.begin()), cannam@147: reinterpret_cast(bytes.end())); cannam@147: } cannam@147: cannam@147: template cannam@147: static typename Type::Reader defaultValue() { cannam@147: return typename Type::Reader(_::StructReader()); cannam@147: } cannam@147: cannam@147: template cannam@147: kj::Array canonicalize(T&& reader) { cannam@147: return _::PointerHelpers>::getInternalReader(reader).canonicalize(); cannam@147: } cannam@147: cannam@147: } // namespace capnp cannam@147: cannam@147: #endif // CAPNP_MESSAGE_H_