cannam@149: // Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors cannam@149: // Licensed under the MIT License: cannam@149: // cannam@149: // Permission is hereby granted, free of charge, to any person obtaining a copy cannam@149: // of this software and associated documentation files (the "Software"), to deal cannam@149: // in the Software without restriction, including without limitation the rights cannam@149: // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell cannam@149: // copies of the Software, and to permit persons to whom the Software is cannam@149: // furnished to do so, subject to the following conditions: cannam@149: // cannam@149: // The above copyright notice and this permission notice shall be included in cannam@149: // all copies or substantial portions of the Software. cannam@149: // cannam@149: // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR cannam@149: // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, cannam@149: // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE cannam@149: // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER cannam@149: // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, cannam@149: // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN cannam@149: // THE SOFTWARE. cannam@149: cannam@149: #ifndef CAPNP_SCHEMA_LOADER_H_ cannam@149: #define CAPNP_SCHEMA_LOADER_H_ cannam@149: cannam@149: #if defined(__GNUC__) && !defined(CAPNP_HEADER_WARNINGS) cannam@149: #pragma GCC system_header cannam@149: #endif cannam@149: cannam@149: #include "schema.h" cannam@149: #include cannam@149: #include cannam@149: cannam@149: namespace capnp { cannam@149: cannam@149: class SchemaLoader { cannam@149: // Class which can be used to construct Schema objects from schema::Nodes as defined in cannam@149: // schema.capnp. cannam@149: // cannam@149: // It is a bad idea to use this class on untrusted input with exceptions disabled -- you may cannam@149: // be exposing yourself to denial-of-service attacks, as attackers can easily construct schemas cannam@149: // that are subtly inconsistent in a way that causes exceptions to be thrown either by cannam@149: // SchemaLoader or by the dynamic API when the schemas are subsequently used. If you enable and cannam@149: // properly catch exceptions, you should be OK -- assuming no bugs in the Cap'n Proto cannam@149: // implementation, of course. cannam@149: cannam@149: public: cannam@149: class LazyLoadCallback { cannam@149: public: cannam@149: virtual void load(const SchemaLoader& loader, uint64_t id) const = 0; cannam@149: // Request that the schema node with the given ID be loaded into the given SchemaLoader. If cannam@149: // the callback is able to find a schema for this ID, it should invoke `loadOnce()` on cannam@149: // `loader` to load it. If no such node exists, it should simply do nothing and return. cannam@149: // cannam@149: // The callback is allowed to load schema nodes other than the one requested, e.g. because it cannam@149: // expects they will be needed soon. cannam@149: // cannam@149: // If the `SchemaLoader` is used from multiple threads, the callback must be thread-safe. cannam@149: // In particular, it's possible for multiple threads to invoke `load()` with the same ID. cannam@149: // If the callback performs a large amount of work to look up IDs, it should be sure to cannam@149: // de-dup these requests. cannam@149: }; cannam@149: cannam@149: SchemaLoader(); cannam@149: cannam@149: SchemaLoader(const LazyLoadCallback& callback); cannam@149: // Construct a SchemaLoader which will invoke the given callback when a schema node is requested cannam@149: // that isn't already loaded. cannam@149: cannam@149: ~SchemaLoader() noexcept(false); cannam@149: KJ_DISALLOW_COPY(SchemaLoader); cannam@149: cannam@149: Schema get(uint64_t id, schema::Brand::Reader brand = schema::Brand::Reader(), cannam@149: Schema scope = Schema()) const; cannam@149: // Gets the schema for the given ID, throwing an exception if it isn't present. cannam@149: // cannam@149: // The returned schema may be invalidated if load() is called with a new schema for the same ID. cannam@149: // In general, you should not call load() while a schema from this loader is in-use. cannam@149: // cannam@149: // `brand` and `scope` are used to determine brand bindings where relevant. `brand` gives cannam@149: // parameter bindings for the target type's brand parameters that were specified at the reference cannam@149: // site. `scope` specifies the scope in which the type ID appeared -- if `brand` itself contains cannam@149: // parameter references or indicates that some parameters will be inherited, these will be cannam@149: // interpreted within / inherited from `scope`. cannam@149: cannam@149: kj::Maybe tryGet(uint64_t id, schema::Brand::Reader bindings = schema::Brand::Reader(), cannam@149: Schema scope = Schema()) const; cannam@149: // Like get() but doesn't throw. cannam@149: cannam@149: Schema getUnbound(uint64_t id) const; cannam@149: // Gets a special version of the schema in which all brand parameters are "unbound". This means cannam@149: // that if you look up a type via the Schema API, and it resolves to a brand parameter, the cannam@149: // returned Type's getBrandParameter() method will return info about that parameter. Otherwise, cannam@149: // normally, all brand parameters that aren't otherwise bound are assumed to simply be cannam@149: // "AnyPointer". cannam@149: cannam@149: Type getType(schema::Type::Reader type, Schema scope = Schema()) const; cannam@149: // Convenience method which interprets a schema::Type to produce a Type object. Implemented in cannam@149: // terms of get(). cannam@149: cannam@149: Schema load(const schema::Node::Reader& reader); cannam@149: // Loads the given schema node. Validates the node and throws an exception if invalid. This cannam@149: // makes a copy of the schema, so the object passed in can be destroyed after this returns. cannam@149: // cannam@149: // If the node has any dependencies which are not already loaded, they will be initialized as cannam@149: // stubs -- empty schemas of whichever kind is expected. cannam@149: // cannam@149: // If another schema for the given reader has already been seen, the loader will inspect both cannam@149: // schemas to determine which one is newer, and use that that one. If the two versions are cannam@149: // found to be incompatible, an exception is thrown. If the two versions differ but are cannam@149: // compatible and the loader cannot determine which is newer (e.g., the only changes are renames), cannam@149: // the existing schema will be preferred. Note that in any case, the loader will end up keeping cannam@149: // around copies of both schemas, so you shouldn't repeatedly reload schemas into the same loader. cannam@149: // cannam@149: // The following properties of the schema node are validated: cannam@149: // - Struct size and preferred list encoding are valid and consistent. cannam@149: // - Struct members are fields or unions. cannam@149: // - Union members are fields. cannam@149: // - Field offsets are in-bounds. cannam@149: // - Ordinals and codeOrders are sequential starting from zero. cannam@149: // - Values are of the right union case to match their types. cannam@149: // cannam@149: // You should assume anything not listed above is NOT validated. In particular, things that are cannam@149: // not validated now, but could be in the future, include but are not limited to: cannam@149: // - Names. cannam@149: // - Annotation values. (This is hard because the annotation declaration is not always cannam@149: // available.) cannam@149: // - Content of default/constant values of pointer type. (Validating these would require knowing cannam@149: // their schema, but even if the schemas are available at validation time, they could be cannam@149: // updated by a subsequent load(), invalidating existing values. Instead, these values are cannam@149: // validated at the time they are used, as usual for Cap'n Proto objects.) cannam@149: // cannam@149: // Also note that unknown types are not considered invalid. Instead, the dynamic API returns cannam@149: // a DynamicValue with type UNKNOWN for these. cannam@149: cannam@149: Schema loadOnce(const schema::Node::Reader& reader) const; cannam@149: // Like `load()` but does nothing if a schema with the same ID is already loaded. In contrast, cannam@149: // `load()` would attempt to compare the schemas and take the newer one. `loadOnce()` is safe cannam@149: // to call even while concurrently using schemas from this loader. It should be considered an cannam@149: // error to call `loadOnce()` with two non-identical schemas that share the same ID, although cannam@149: // this error may or may not actually be detected by the implementation. cannam@149: cannam@149: template cannam@149: void loadCompiledTypeAndDependencies(); cannam@149: // Load the schema for the given compiled-in type and all of its dependencies. cannam@149: // cannam@149: // If you want to be able to cast a DynamicValue built from this SchemaLoader to the compiled-in cannam@149: // type using as(), you must call this method before constructing the DynamicValue. Otherwise, cannam@149: // as() will throw an exception complaining about type mismatch. cannam@149: cannam@149: kj::Array getAllLoaded() const; cannam@149: // Get a complete list of all loaded schema nodes. It is particularly useful to call this after cannam@149: // loadCompiledTypeAndDependencies() in order to get a flat list of all of T's transitive cannam@149: // dependencies. cannam@149: cannam@149: private: cannam@149: class Validator; cannam@149: class CompatibilityChecker; cannam@149: class Impl; cannam@149: class InitializerImpl; cannam@149: class BrandedInitializerImpl; cannam@149: kj::MutexGuarded> impl; cannam@149: cannam@149: void loadNative(const _::RawSchema* nativeSchema); cannam@149: }; cannam@149: cannam@149: template cannam@149: inline void SchemaLoader::loadCompiledTypeAndDependencies() { cannam@149: loadNative(&_::rawSchema()); cannam@149: } cannam@149: cannam@149: } // namespace capnp cannam@149: cannam@149: #endif // CAPNP_SCHEMA_LOADER_H_