Loading...
--- /dev/null
+++ xnu/xnu-12377.121.6/libkern/c++/OSSerializeBinary.cpp
@@ -0,0 +1,678 @@
+/*
+ * Copyright (c) 2014 Apple Computer, Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+
+
+#include <libkern/c++/OSSharedPtr.h>
+#include <libkern/OSSerializeBinary.h>
+#include <libkern/c++/OSContainers.h>
+#include <libkern/c++/OSLib.h>
+#include <libkern/c++/OSDictionary.h>
+#include <libkern/OSSerializeBinary.h>
+#include <libkern/c++/OSSharedPtr.h>
+
+#include <IOKit/IOLib.h>
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#if 0
+#define DEBG(fmt, args ...) { kprintf(fmt, args); }
+#else
+#define DEBG(fmt, args ...) {}
+#endif
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+OSSerialize *
+OSSerialize::binaryWithCapacity(unsigned int inCapacity,
+ Editor editor, void * reference)
+{
+ OSSerialize *me;
+
+ if (inCapacity < sizeof(uint32_t)) {
+ return NULL;
+ }
+ me = OSSerialize::withCapacity(inCapacity);
+ if (!me) {
+ return NULL;
+ }
+
+ me->binary = true;
+ me->endCollection = true;
+ me->editor = editor;
+ me->editRef = reference;
+
+ bcopy(kOSSerializeBinarySignature, &me->data[0], sizeof(kOSSerializeBinarySignature));
+ me->length = sizeof(kOSSerializeBinarySignature);
+
+ return me;
+}
+
+bool
+OSSerialize::addBinary(const void * bits, size_t size)
+{
+ unsigned int newCapacity;
+ size_t alignSize;
+
+ if (os_add_overflow(size, 3, &alignSize)) {
+ return false;
+ }
+ alignSize &= ~3L;
+ if (os_add_overflow(length, alignSize, &newCapacity)) {
+ return false;
+ }
+ if (newCapacity >= capacity) {
+ newCapacity = (((newCapacity - 1) / capacityIncrement) + 1) * capacityIncrement;
+ if (newCapacity < capacity) {
+ return false;
+ }
+ if (newCapacity > ensureCapacity(newCapacity)) {
+ return false;
+ }
+ }
+
+ bcopy(bits, &data[length], size);
+ length += alignSize;
+
+ return true;
+}
+
+void
+OSSerialize::setIndexed(bool index __unused)
+{
+ assert(index && !indexData);
+ indexData = OSData::withCapacity(256);
+ assert(indexData);
+}
+
+bool
+OSSerialize::addBinaryObject(const OSMetaClassBase * o, uint32_t key,
+ const void * bits, uint32_t size,
+ uint32_t * startCollection)
+{
+ unsigned int newCapacity;
+ size_t alignSize;
+ size_t headerSize;
+
+ // add to tag array
+ tags->setObject(o);
+
+ headerSize = sizeof(key);
+ if (indexData) {
+ uint32_t offset = length;
+ if (startCollection) {
+ *startCollection = offset;
+ headerSize += sizeof(uint32_t);
+ }
+ offset /= sizeof(uint32_t);
+ indexData->appendValue(offset);
+ }
+
+ if (os_add3_overflow(size, headerSize, 3, &alignSize)) {
+ return false;
+ }
+ alignSize &= ~3L;
+ if (os_add_overflow(length, alignSize, &newCapacity)) {
+ return false;
+ }
+ if (newCapacity >= capacity) {
+ newCapacity = (((newCapacity - 1) / capacityIncrement) + 1) * capacityIncrement;
+ if (newCapacity < capacity) {
+ return false;
+ }
+ if (newCapacity > ensureCapacity(newCapacity)) {
+ return false;
+ }
+ }
+
+ if (endCollection) {
+ endCollection = false;
+ key |= kOSSerializeEndCollecton;
+ }
+
+ bcopy(&key, &data[length], sizeof(key));
+ bcopy(bits, &data[length + headerSize], size);
+ length += alignSize;
+
+ return true;
+}
+
+void
+OSSerialize::endBinaryCollection(uint32_t startCollection)
+{
+ uint32_t clength;
+
+ if (!indexData) {
+ return;
+ }
+
+ assert(length > startCollection);
+ if (length <= startCollection) {
+ return;
+ }
+
+ clength = length - startCollection;
+ assert(!(clength & 3));
+ clength /= sizeof(uint32_t);
+
+ memcpy(&data[startCollection + sizeof(uint32_t)], &clength, sizeof(clength));
+}
+
+bool
+OSSerialize::binarySerialize(const OSMetaClassBase *o)
+{
+ bool ok;
+ uint32_t header;
+
+ ok = binarySerializeInternal(o);
+ if (!ok) {
+ return ok;
+ }
+
+ if (indexData) {
+ header = indexData->getLength() / sizeof(uint32_t);
+ assert(header <= kOSSerializeDataMask);
+ header <<= 8;
+ header |= kOSSerializeIndexedBinarySignature;
+
+ memcpy(&data[0], &header, sizeof(header));
+ }
+
+ return ok;
+}
+
+bool
+OSSerialize::binarySerializeInternal(const OSMetaClassBase *o)
+{
+ OSDictionary * dict;
+ OSArray * array;
+ OSSet * set;
+ OSNumber * num;
+ OSSymbol * sym;
+ OSString * str;
+ OSData * ldata;
+ OSBoolean * boo;
+
+ unsigned int tagIdx;
+ uint32_t i, key, startCollection = 0;
+ uint32_t len;
+ bool ok;
+
+ tagIdx = tags->getNextIndexOfObject(o, 0);
+ // does it exist?
+ if (-1U != tagIdx) {
+ if (indexData) {
+ assert(indexData->getLength() > (tagIdx * sizeof(uint32_t)));
+ tagIdx = ((const uint32_t *)indexData->getBytesNoCopy())[tagIdx];
+ assert(tagIdx <= kOSSerializeDataMask);
+ }
+ key = (kOSSerializeObject | tagIdx);
+ if (endCollection) {
+ endCollection = false;
+ key |= kOSSerializeEndCollecton;
+ }
+ ok = addBinary(&key, sizeof(key));
+ return ok;
+ }
+
+ if ((dict = OSDynamicCast(OSDictionary, o))) {
+ key = (kOSSerializeDictionary | dict->count);
+ ok = addBinaryObject(o, key, NULL, 0, &startCollection);
+ for (i = 0; ok && (i < dict->count);) {
+ const OSSymbol * dictKey;
+ const OSMetaClassBase * dictValue;
+ const OSMetaClassBase * nvalue = NULL;
+
+ dictKey = dict->dictionary[i].key;
+ dictValue = dict->dictionary[i].value;
+ i++;
+ if (editor) {
+ dictValue = nvalue = (*editor)(editRef, this, dict, dictKey, dictValue);
+ if (!dictValue) {
+ dictValue = dict;
+ }
+ }
+ ok = binarySerialize(dictKey);
+ if (!ok) {
+ break;
+ }
+ endCollection = (i == dict->count);
+ ok = binarySerialize(dictValue);
+ if (!ok) {
+ ok = dictValue->serialize(this);
+ }
+ if (nvalue) {
+ nvalue->release();
+ }
+// if (!ok) ok = binarySerialize(kOSBooleanFalse);
+ }
+ endBinaryCollection(startCollection);
+ } else if ((array = OSDynamicCast(OSArray, o))) {
+ key = (kOSSerializeArray | array->count);
+ ok = addBinaryObject(o, key, NULL, 0, &startCollection);
+ for (i = 0; ok && (i < array->count);) {
+ i++;
+ endCollection = (i == array->count);
+ ok = binarySerialize(array->array[i - 1]);
+ if (!ok) {
+ ok = array->array[i - 1]->serialize(this);
+ }
+// if (!ok) ok = binarySerialize(kOSBooleanFalse);
+ }
+ endBinaryCollection(startCollection);
+ } else if ((set = OSDynamicCast(OSSet, o))) {
+ key = (kOSSerializeSet | set->members->count);
+ ok = addBinaryObject(o, key, NULL, 0, &startCollection);
+ for (i = 0; ok && (i < set->members->count);) {
+ i++;
+ endCollection = (i == set->members->count);
+ ok = binarySerialize(set->members->array[i - 1]);
+ if (!ok) {
+ ok = set->members->array[i - 1]->serialize(this);
+ }
+// if (!ok) ok = binarySerialize(kOSBooleanFalse);
+ }
+ endBinaryCollection(startCollection);
+ } else if ((num = OSDynamicCast(OSNumber, o))) {
+ key = (kOSSerializeNumber | num->size);
+ ok = addBinaryObject(o, key, &num->value, sizeof(num->value), NULL);
+ } else if ((boo = OSDynamicCast(OSBoolean, o))) {
+ key = (kOSSerializeBoolean | (kOSBooleanTrue == boo));
+ ok = addBinaryObject(o, key, NULL, 0, NULL);
+ } else if ((sym = OSDynamicCast(OSSymbol, o))) {
+ len = (sym->getLength() + 1);
+ key = (kOSSerializeSymbol | len);
+ ok = addBinaryObject(o, key, sym->getCStringNoCopy(), len, NULL);
+ } else if ((str = OSDynamicCast(OSString, o))) {
+ len = str->getLength();
+ key = (kOSSerializeString | len);
+ ok = addBinaryObject(o, key, str->getCStringNoCopy(), len, NULL);
+ } else if ((ldata = OSDynamicCast(OSData, o))) {
+ len = ldata->getLength();
+ if (ldata->reserved && ldata->reserved->disableSerialization) {
+ len = 0;
+ }
+ key = (kOSSerializeData | len);
+ ok = addBinaryObject(o, key, ldata->getBytesNoCopy(), len, NULL);
+ } else {
+ return false;
+ }
+
+ return ok;
+}
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#define setAtIndex(v, idx, o) \
+ ok = idx < v##Capacity; \
+ if (!ok && v##Capacity < v##CapacityMax) { \
+ uint32_t ncap = v##Capacity + 64; \
+ typeof(v##Array) nbuf = kreallocp_type_container(OSObject *, \
+ v##Array, v##Capacity, &ncap, Z_WAITOK_ZERO); \
+ if (nbuf) { \
+ ok = true; \
+ v##Array = nbuf; \
+ v##Capacity = ncap; \
+ } \
+ } \
+ if (ok) v##Array[idx] = o
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+OSObject *
+OSUnserializeBinary(const char *buffer, size_t bufferSize, OSString **errorString)
+{
+ OSObject ** objsArray;
+ uint32_t objsCapacity;
+ enum { objsCapacityMax = 16 * 1024 * 1024 };
+ uint32_t objsIdx;
+
+ OSObject ** stackArray;
+ uint32_t stackCapacity;
+ enum { stackCapacityMax = 64 };
+ uint32_t stackIdx;
+
+ OSObject * result;
+ OSObject * parent;
+ OSDictionary * dict;
+ OSArray * array;
+ OSSet * set;
+ OSDictionary * newDict;
+ OSArray * newArray;
+ OSSet * newSet;
+ OSObject * o;
+ OSSymbol * sym;
+ OSString * str;
+
+ size_t bufferPos;
+ const uint32_t * next;
+ uint32_t key, len, wordLen, length;
+ bool end, newCollect, isRef;
+ union {
+ unsigned long long value;
+ double fpValue;
+ } value;
+ bool ok, indexed, hasLength;
+
+ indexed = false;
+ if (errorString) {
+ *errorString = NULL;
+ }
+
+ if (bufferSize < sizeof(kOSSerializeBinarySignature)) {
+ return NULL;
+ }
+ if (kOSSerializeIndexedBinarySignature == (((const uint8_t *) buffer)[0])) {
+ indexed = true;
+ } else if (0 != strcmp(kOSSerializeBinarySignature, buffer)) {
+ return NULL;
+ }
+ if (3 & ((uintptr_t) buffer)) {
+ return NULL;
+ }
+
+ bufferPos = sizeof(kOSSerializeBinarySignature);
+ next = (typeof(next))(((uintptr_t) buffer) + bufferPos);
+
+ DEBG("---------OSUnserializeBinary(%p)\n", buffer);
+
+ objsArray = stackArray = NULL;
+ objsIdx = objsCapacity = 0;
+ stackIdx = stackCapacity = 0;
+
+ result = NULL;
+ parent = NULL;
+ dict = NULL;
+ array = NULL;
+ set = NULL;
+ sym = NULL;
+
+ ok = true;
+ while (ok) {
+ bufferPos += sizeof(*next);
+ if (!(ok = (bufferPos <= bufferSize))) {
+ break;
+ }
+ key = *next++;
+ length = 0;
+
+ len = (key & kOSSerializeDataMask);
+ wordLen = (len + 3) >> 2;
+ end = (0 != (kOSSerializeEndCollecton & key));
+ DEBG("key 0x%08x: 0x%04x, %d\n", key, len, end);
+
+ newCollect = isRef = hasLength = false;
+ o = NULL; newDict = NULL; newArray = NULL; newSet = NULL;
+
+ switch (kOSSerializeTypeMask & key) {
+ case kOSSerializeDictionary:
+ o = newDict = OSDictionary::withCapacity(len);
+ newCollect = (len != 0);
+ hasLength = indexed;
+ break;
+ case kOSSerializeArray:
+ o = newArray = OSArray::withCapacity(len);
+ newCollect = (len != 0);
+ hasLength = indexed;
+ break;
+ case kOSSerializeSet:
+ o = newSet = OSSet::withCapacity(len);
+ newCollect = (len != 0);
+ hasLength = indexed;
+ break;
+
+ case kOSSerializeObject:
+ if (len >= objsIdx) {
+ break;
+ }
+ o = objsArray[len];
+ isRef = true;
+ break;
+
+ case kOSSerializeNumber:
+ bufferPos += sizeof(long long);
+ if (bufferPos > bufferSize) {
+ break;
+ }
+ value.value = next[1];
+ value.value <<= 32;
+ value.value |= next[0];
+ switch (len) {
+ case 63:
+ o = OSNumber::withDouble(value.fpValue);
+ break;
+ case 31:
+ o = OSNumber::withFloat((float) value.fpValue);
+ break;
+ case 64:
+ case 32:
+ case 16:
+ case 8:
+ o = OSNumber::withNumber(value.value, len);
+ break;
+ }
+ next += 2;
+ break;
+
+ case kOSSerializeSymbol:
+ bufferPos += (wordLen * sizeof(uint32_t));
+ if (bufferPos > bufferSize) {
+ break;
+ }
+ if (len < 1) {
+ break;
+ }
+ if (0 != ((const char *)next)[len - 1]) {
+ break;
+ }
+ o = (OSObject *) OSSymbol::withCString((const char *) next);
+ next += wordLen;
+ break;
+
+ case kOSSerializeString:
+ bufferPos += (wordLen * sizeof(uint32_t));
+ if (bufferPos > bufferSize) {
+ break;
+ }
+ o = OSString::withCString((const char *) next, len);
+ next += wordLen;
+ break;
+
+ case kOSSerializeData:
+ bufferPos += (wordLen * sizeof(uint32_t));
+ if (bufferPos > bufferSize) {
+ break;
+ }
+ o = OSData::withBytes(next, len);
+ next += wordLen;
+ break;
+
+ case kOSSerializeBoolean:
+ o = (len ? kOSBooleanTrue : kOSBooleanFalse);
+ break;
+
+ default:
+ break;
+ }
+
+ if (!(ok = (o != NULL))) {
+ break;
+ }
+
+ if (hasLength) {
+ bufferPos += sizeof(*next);
+ if (!(ok = (bufferPos <= bufferSize))) {
+ o->release();
+ break;
+ }
+ length = *next++;
+ }
+
+ if (!isRef) {
+ setAtIndex(objs, objsIdx, o);
+ if (!ok) {
+ o->release();
+ break;
+ }
+ objsIdx++;
+ }
+
+ if (dict) {
+ if (!sym) {
+ sym = (OSSymbol *) o;
+ } else {
+ str = sym;
+ sym = OSDynamicCast(OSSymbol, sym);
+ if (!sym && (str = OSDynamicCast(OSString, str))) {
+ sym = const_cast<OSSymbol *>(OSSymbol::withString(str));
+ ok = (sym != NULL);
+ if (!ok) {
+ break;
+ }
+ }
+ DEBG("%s = %s\n", sym->getCStringNoCopy(), o->getMetaClass()->getClassName());
+ if (o != dict) {
+ ok = dict->setObject(sym, o);
+ }
+ if (sym && (sym != str)) {
+ sym->release();
+ }
+ sym = NULL;
+ }
+ } else if (array) {
+ ok = array->setObject(o);
+ } else if (set) {
+ ok = set->setObject(o);
+ } else if (result) {
+ ok = false;
+ } else {
+ assert(!parent);
+ result = o;
+ }
+
+ if (!ok) {
+ break;
+ }
+
+ if (end) {
+ parent = NULL;
+ }
+ if (newCollect) {
+ stackIdx++;
+ setAtIndex(stack, stackIdx, parent);
+ if (!ok) {
+ break;
+ }
+ DEBG("++stack[%d] %p\n", stackIdx, parent);
+ parent = o;
+ dict = newDict;
+ array = newArray;
+ set = newSet;
+ end = false;
+ }
+
+ if (end) {
+ while (stackIdx) {
+ parent = stackArray[stackIdx];
+ DEBG("--stack[%d] %p\n", stackIdx, parent);
+ stackIdx--;
+ if (parent) {
+ break;
+ }
+ }
+ if (!parent) {
+ break;
+ }
+ set = NULL;
+ dict = NULL;
+ array = NULL;
+ if (!(dict = OSDynamicCast(OSDictionary, parent))) {
+ if (!(array = OSDynamicCast(OSArray, parent))) {
+ ok = (NULL != (set = OSDynamicCast(OSSet, parent)));
+ }
+ }
+ }
+ }
+ DEBG("ret %p\n", result);
+
+ if (!ok) {
+ result = NULL;
+ }
+
+ if (objsCapacity) {
+ for (len = (result != NULL); len < objsIdx; len++) {
+ objsArray[len]->release();
+ }
+ kfree_type(OSObject *, objsCapacity, objsArray);
+ }
+ if (stackCapacity) {
+ kfree_type(OSObject *, stackCapacity, stackArray);
+ }
+
+ return result;
+}
+
+OSObject*
+OSUnserializeXML(
+ const char * buffer,
+ OSSharedPtr<OSString>& errorString)
+{
+ OSString* errorStringRaw = NULL;
+ OSObject* result = OSUnserializeXML(buffer, &errorStringRaw);
+ errorString.reset(errorStringRaw, OSNoRetain);
+ return result;
+}
+
+OSObject*
+OSUnserializeXML(
+ const char * buffer,
+ size_t bufferSize,
+ OSSharedPtr<OSString> &errorString)
+{
+ OSString* errorStringRaw = NULL;
+ OSObject* result = OSUnserializeXML(buffer, bufferSize, &errorStringRaw);
+ errorString.reset(errorStringRaw, OSNoRetain);
+ return result;
+}
+
+OSObject*
+OSUnserializeBinary(const char *buffer, size_t bufferSize, OSSharedPtr<OSString>& errorString)
+{
+ OSString* errorStringRaw = NULL;
+ OSObject* result = OSUnserializeBinary(buffer, bufferSize, &errorStringRaw);
+ errorString.reset(errorStringRaw, OSNoRetain);
+ return result;
+}
+
+OSObject*
+OSUnserialize(const char *buffer, OSSharedPtr<OSString>& errorString)
+{
+ OSString* errorStringRaw = NULL;
+ OSObject* result = OSUnserialize(buffer, &errorStringRaw);
+ errorString.reset(errorStringRaw, OSNoRetain);
+ return result;
+}