--- /dev/null
+//
+// SuperBlob - a typed bag of Blobs
+//
+#ifndef _H_SUPERBLOB
+#define _H_SUPERBLOB
+
+#include "blob.h"
+#include <assert.h>
+#include <utility>
+#include <map>
+
+using namespace std;
+
+namespace Security {
+
+
+//
+// A SuperBlob is a Blob that contains multiple sub-Blobs of varying type.
+// The SuperBlob is contiguous and contains a directory of its sub-blobs.
+// A Maker is included.
+//
+// SuperBlobCore lets you define your own SuperBlob type. To just use a generic
+// SuperBlob, use SuperBlob<> below.
+//
+template <class _BlobType, uint32_t _magic, class _Type>
+class SuperBlobCore: public Blob<_BlobType, _magic> {
+public:
+ class Maker; friend class Maker;
+
+ typedef _Type Type;
+
+ // echoes from parent BlobCore (the C++ type system is too restrictive here)
+ typedef BlobCore::Offset Offset;
+ template <class BlobType> BlobType *at(Offset offset) { return BlobCore::at<BlobType>(offset); }
+ template <class BlobType> const BlobType *at(Offset offset) const { return BlobCore::at<BlobType>(offset); }
+
+ void setup(size_t size, unsigned cnt)
+ { this->initialize(size); this->mCount = cnt; }
+
+ struct Index {
+ Endian<Type> type; // type of sub-Blob
+ Endian<Offset> offset; // starting offset
+ };
+
+ bool validateBlob(size_t maxSize = 0) const;
+
+ unsigned count() const { return mCount; }
+
+ // access by index number
+ Type type(unsigned n) const { assert(n < mCount); return mIndex[n].type; }
+ const BlobCore *blob(unsigned n) const { assert(n < mCount); Offset off=mIndex[n].offset; return off ? at<const BlobCore>(off) : NULL; }
+
+ template <class BlobType>
+ const BlobType *blob(unsigned n) const { return BlobType::specific(blob(n)); }
+
+ // access by index type (assumes unique types)
+ const BlobCore *find(Type type) const;
+ template <class BlobType>
+ const BlobType *find(Type t) const { return BlobType::specific(find(t)); }
+
+private:
+ Endian<uint32_t> mCount; // number of sub-Blobs following
+ Index mIndex[0]; // <count> IndexSlot structures
+ // followed by sub-Blobs, packed and ordered in an undefined way
+};
+
+
+template <class _BlobType, uint32_t _magic, class _Type>
+inline bool SuperBlobCore<_BlobType, _magic, _Type>::validateBlob(size_t maxSize /* = 0 */) const
+{
+ unsigned cnt = mCount;
+ size_t ixLimit = sizeof(SuperBlobCore) + cnt * sizeof(Index); // end of index vector
+ if (!BlobCore::validateBlob(_magic, ixLimit, maxSize))
+ return false;
+
+ for (const Index *ix = mIndex + cnt - 1; ix >= mIndex; ix--) {
+ Offset offset = ix->offset;
+ if ( offset == 0 )
+ continue; // offset==0 means unused entry
+ if (offset < ixLimit // offset not too small
+ || offset + sizeof(BlobCore) > this->length() // fits Blob header (including length field)
+ || offset + at<const BlobCore>(offset)->length() > this->length()) // fits entire blob
+ return false;
+ }
+ return true;
+}
+
+
+//
+// A generic SuperBlob ready for use. You still need to specify a magic number.
+//
+template <uint32_t _magic, class _Type = uint32_t>
+class SuperBlob : public SuperBlobCore<SuperBlob<_magic, _Type>, _magic, _Type> {
+};
+
+
+template <class _BlobType, uint32_t _magic, class _Type>
+const BlobCore *SuperBlobCore<_BlobType, _magic, _Type>::find(Type t) const
+{
+ for (unsigned slot = 0; slot < mCount; slot++) {
+ if (mIndex[slot].type == t) {
+ uint32_t off = mIndex[slot].offset;
+ if ( off == 0 )
+ return NULL;
+ else
+ return at<const BlobCore>(off);
+ }
+ }
+ return NULL; // not found
+}
+
+
+//
+// A SuperBlob::Maker simply assembles multiple Blobs into a single, indexed
+// super-blob. Just add() sub-Blobs by type and call build() to get
+// the result, malloc'ed. A Maker is not reusable.
+// Maker can repeatedly make SuperBlobs from the same (cached) inputs.
+// It can also tell you how big its output will be, given established contents
+// plus (optional) additional sizes of blobs yet to come.
+//
+template <class _BlobType, uint32_t _magic, class _Type>
+class SuperBlobCore<_BlobType, _magic, _Type>::Maker {
+public:
+ Maker() { }
+
+ Maker(const Maker &src)
+ {
+ for (typename BlobMap::iterator it = mPieces.begin(); it != mPieces.end(); ++it)
+ mPieces.insert(make_pair(it->first, it->second->clone()));
+ }
+
+ ~Maker()
+ {
+ for (typename BlobMap::iterator it = mPieces.begin(); it != mPieces.end(); ++it)
+ ::free(it->second);
+ }
+
+ void add(Type type, BlobCore *blob); // takes ownership of blob
+ void add(const _BlobType *blobs); // copies all blobs
+ void add(const Maker &maker); // ditto
+
+ size_t size(size_t size1 = 0, ...) const; // size with optional additional blob sizes
+ _BlobType *make() const; // create (malloc) and return SuperBlob
+ _BlobType *operator () () const { return make(); }
+
+private:
+ typedef std::map<Type, BlobCore *> BlobMap;
+ BlobMap mPieces;
+};
+
+
+//
+// Add a Blob to a SuperBlob::Maker.
+// This takes ownership of the blob, which must have been malloc'ed.
+// Any previous value set for this Type will be freed immediately.
+//
+template <class _BlobType, uint32_t _magic, class _Type>
+void SuperBlobCore<_BlobType, _magic, _Type>::Maker::add(Type type, BlobCore *blob)
+{
+ pair<typename BlobMap::iterator, bool> r = mPieces.insert(make_pair(type, blob));
+ if (!r.second) { // already there
+ //secdebug("superblob", "Maker %p replaces type=%d", this, type);
+ ::free(r.first->second);
+ r.first->second = blob;
+ }
+}
+
+template <class _BlobType, uint32_t _magic, class _Type>
+void SuperBlobCore<_BlobType, _magic, _Type>::Maker::add(const _BlobType *blobs)
+{
+ for (uint32_t ix = 0; ix < blobs->mCount; ix++)
+ this->add(blobs->mIndex[ix].type, blobs->blob(ix)->clone());
+}
+
+template <class _BlobType, uint32_t _magic, class _Type>
+void SuperBlobCore<_BlobType, _magic, _Type>::Maker::add(const Maker &maker)
+{
+ for (typename BlobMap::const_iterator it = maker.mPieces.begin(); it != maker.mPieces.end(); ++it)
+ this->add(it->first, it->second->clone());
+}
+
+
+//
+// Calculate the size the new SuperBlob would have, given the contents of the Maker
+// so far, plus additional blobs with the sizes given.
+//
+template <class _BlobType, uint32_t _magic, class _Type>
+size_t SuperBlobCore<_BlobType, _magic, _Type>::Maker::size(size_t size1, ...) const
+{
+ // count established blobs
+ unsigned count = mPieces.size();
+ size_t total = 0;
+ for (typename BlobMap::const_iterator it = mPieces.begin(); it != mPieces.end(); ++it) {
+ if ( it->second != NULL )
+ total += (it->second->length() + 3) & (-4); // 4-byte align each element
+ }
+
+ // add preview blob sizes to calculation (if any)
+ if (size1) {
+ va_list args;
+ va_start(args, size1);
+ do {
+ count++;
+ total += size1;
+ size1 = va_arg(args, size_t);
+ } while (size1);
+ va_end(args);
+ }
+
+ return sizeof(SuperBlobCore) + count * sizeof(Index) + total;
+}
+
+
+//
+// Finish SuperBlob construction and return the new, malloc'ed, SuperBlob.
+// This can be done repeatedly.
+//
+template <class _BlobType, uint32_t _magic, class _Type>
+_BlobType *SuperBlobCore<_BlobType, _magic, _Type>::Maker::make() const
+{
+ Offset pc = sizeof(SuperBlobCore) + mPieces.size() * sizeof(Index);
+ Offset total = size();
+ _BlobType *result = (_BlobType *)calloc(1, total);
+ if (!result)
+ throw ENOMEM;
+ result->setup(total, mPieces.size());
+ unsigned n = 0;
+ for (typename BlobMap::const_iterator it = mPieces.begin(); it != mPieces.end(); ++it) {
+ result->mIndex[n].type = it->first;
+ BlobCore* b = it->second;
+ if ( b != NULL ) {
+ result->mIndex[n].offset = pc;
+ memcpy(result->template at<unsigned char>(pc), b, b->length());
+ pc += ((b->length() + 3) & (-4)); // 4-byte align each element
+ }
+ else {
+ result->mIndex[n].offset = 0;
+ }
+ n++;
+ }
+ //secdebug("superblob", "Maker %p assembles %ld blob(s) into %p (size=%d)",
+ // this, mPieces.size(), result, total);
+ return result;
+}
+
+
+} // Security
+
+#endif //_H_SUPERBLOB
projects / apple / ld64.git / blobdiff