mirror of
https://github.com/apple-oss-distributions/xnu.git
synced 2026-01-11 20:06:33 +00:00
468 lines
14 KiB
Objective-C
468 lines
14 KiB
Objective-C
/*
|
|
* Copyright (c) 2015 Apple 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 <kcdata.h>
|
|
#import <Foundation/Foundation.h>
|
|
#import "kdd.h"
|
|
#import "KCDBasicTypeDescription.h"
|
|
#import "KCDStructTypeDescription.h"
|
|
#import "KCDEmbeddedBufferDescription.h"
|
|
|
|
#define LIB_KCD_ERR_DOMAIN @"KCDataError"
|
|
|
|
#define GEN_ERROR(code, msg) gen_error(__LINE__, code, @msg)
|
|
#define GEN_ERRORF(code, msg, ...) gen_error(__LINE__, code, [NSString stringWithFormat:@msg, __VA_ARGS__])
|
|
|
|
#define MAX_KCDATATYPE_BUFFER_SIZE 2048
|
|
extern struct kcdata_type_definition * kcdata_get_typedescription(unsigned type_id, uint8_t * buffer, uint32_t buffer_size);
|
|
|
|
BOOL setKCDataTypeForID(uint32_t newTypeID, KCDataType *newTypeObj);
|
|
|
|
static NSError *
|
|
gen_error(int line, NSInteger code, NSString *message)
|
|
{
|
|
return [NSError errorWithDomain:LIB_KCD_ERR_DOMAIN
|
|
code:code
|
|
userInfo:@{ @"line": @(line), @"message": message }];
|
|
}
|
|
|
|
static BOOL
|
|
mergedict(NSMutableDictionary * container, NSDictionary * object, NSError ** error)
|
|
{
|
|
for (id key in object) {
|
|
id existing = container[key];
|
|
id new = object[key];
|
|
if (existing) {
|
|
if ([existing isKindOfClass:[NSMutableArray class]] && [new isKindOfClass:[ NSArray class ]]) {
|
|
[existing addObjectsFromArray:new];
|
|
} else {
|
|
if (error) {
|
|
*error = GEN_ERRORF(KERN_INVALID_OBJECT, "repeated key: %@", key);
|
|
}
|
|
return FALSE;
|
|
}
|
|
} else {
|
|
[container setValue:new forKey:key];
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/*!
|
|
* @function getTypeFromTypeDef
|
|
*
|
|
* @abstract
|
|
* Build a KCDataType from a type definition.
|
|
*
|
|
* @param typeDef
|
|
* A pointer to kcdata_type_definition_t that specifies the type fields and has subtype definitions
|
|
* in the memory immediately following the type_definition.
|
|
*
|
|
* @return KCDataType * type object which can be used to parse data into dictionaries.
|
|
* This may return nil if it finds the data to be invalid.
|
|
*
|
|
* @discussion
|
|
* This routine tries to decode the typeDef structure and create either a basic type (KCDBasicTypeDescription)
|
|
* or a struct type.
|
|
*/
|
|
static KCDataType * getTypeFromTypeDef(struct kcdata_type_definition * typeDef);
|
|
|
|
static KCDataType *
|
|
getTypeFromTypeDef(struct kcdata_type_definition * typeDef)
|
|
{
|
|
if (typeDef == NULL) {
|
|
return nil;
|
|
}
|
|
NSString * kct_name = [NSString stringWithFormat:@"%s", typeDef->kct_name];
|
|
if (typeDef->kct_num_elements == 1 && !(typeDef->kct_elements[0].kcs_flags & KCS_SUBTYPE_FLAGS_STRUCT)) {
|
|
KCDBasicTypeDescription * retval = [[KCDBasicTypeDescription alloc] initWithKCTypeDesc:&typeDef->kct_elements[0]];
|
|
return retval;
|
|
} else {
|
|
KCDStructTypeDescription * retval =
|
|
[[KCDStructTypeDescription alloc] initWithType:typeDef->kct_type_identifier withName:kct_name];
|
|
/* need to do work here to get the array of elements setup here */
|
|
KCDBasicTypeDescription * curField = nil;
|
|
for (unsigned int i = 0; i < typeDef->kct_num_elements; i++) {
|
|
curField = [[KCDBasicTypeDescription alloc] initWithKCTypeDesc:&typeDef->kct_elements[i]];
|
|
[retval addFieldBasicType:curField];
|
|
if (typeDef->kct_elements[i].kcs_flags & KCS_SUBTYPE_FLAGS_MERGE) {
|
|
[retval setFlagsRequestedMerge];
|
|
}
|
|
}
|
|
return retval;
|
|
}
|
|
return nil;
|
|
}
|
|
|
|
static dispatch_once_t onceToken;
|
|
static NSMutableDictionary * knownTypes = nil;
|
|
|
|
KCDataType *
|
|
getKCDataTypeForID(uint32_t typeID)
|
|
{
|
|
dispatch_once(&onceToken, ^{
|
|
if (!knownTypes) {
|
|
knownTypes = [[NSMutableDictionary alloc] init];
|
|
}
|
|
});
|
|
|
|
NSNumber * type = [NSNumber numberWithUnsignedInt:typeID];
|
|
if (!knownTypes[type]) {
|
|
if (typeID == KCDATA_TYPE_NESTED_KCDATA) {
|
|
knownTypes[type] = [[KCDEmbeddedBufferDescription alloc] init];
|
|
return knownTypes[type];
|
|
}
|
|
/* code to query system for type information */
|
|
uint8_t buffer[MAX_KCDATATYPE_BUFFER_SIZE];
|
|
struct kcdata_type_definition * sys_def = kcdata_get_typedescription(typeID, buffer, MAX_KCDATATYPE_BUFFER_SIZE);
|
|
if (sys_def == NULL) {
|
|
knownTypes[type] = [[KCDBasicTypeDescription alloc] createDefaultForType:typeID];
|
|
} else {
|
|
knownTypes[type] = getTypeFromTypeDef(sys_def);
|
|
}
|
|
}
|
|
assert(knownTypes[type] != nil);
|
|
return knownTypes[type];
|
|
}
|
|
|
|
BOOL
|
|
setKCDataTypeForID(uint32_t newTypeID, KCDataType *newTypeObj) {
|
|
if (newTypeObj == NULL || newTypeID == 0) {
|
|
return FALSE;
|
|
}
|
|
|
|
dispatch_once(&onceToken, ^{
|
|
if (!knownTypes) {
|
|
knownTypes = [[NSMutableDictionary alloc] init];
|
|
}
|
|
});
|
|
|
|
NSNumber * type = [NSNumber numberWithUnsignedInt:newTypeID];
|
|
|
|
if (!knownTypes[type]) {
|
|
knownTypes[type] = newTypeObj;
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
NSString *
|
|
KCDataTypeNameForID(uint32_t typeID)
|
|
{
|
|
NSString * retval = [NSString stringWithFormat:@"%u", typeID];
|
|
KCDataType * t = getKCDataTypeForID(typeID);
|
|
|
|
if (![[t name] containsString:@"Type_"]) {
|
|
retval = [t name];
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
NSMutableDictionary *
|
|
parseKCDataArray(kcdata_iter_t iter, NSError **error)
|
|
{
|
|
if (!kcdata_iter_array_valid(iter)) {
|
|
if (error)
|
|
*error = GEN_ERROR(KERN_INVALID_OBJECT, "invalid array");
|
|
return NULL;
|
|
}
|
|
|
|
uint32_t typeID = kcdata_iter_array_elem_type(iter);
|
|
uint32_t count = kcdata_iter_array_elem_count(iter);
|
|
uint32_t size = kcdata_iter_array_elem_size(iter);
|
|
uint8_t * buffer = (uint8_t *)kcdata_iter_payload(iter);
|
|
KCDataType * datatype = getKCDataTypeForID(typeID);
|
|
NSMutableDictionary * retval = [[NSMutableDictionary alloc] initWithCapacity:1];
|
|
NSMutableArray * arr = [[NSMutableArray alloc] initWithCapacity:count];
|
|
retval[[datatype name]] = arr;
|
|
NSDictionary * tmpdict = NULL;
|
|
for (uint32_t i = 0; i < count; i++) {
|
|
tmpdict = [datatype parseData:(void *)&buffer[i * size] ofLength:size];
|
|
if (!tmpdict) {
|
|
if (error)
|
|
*error = GEN_ERRORF(KERN_INVALID_OBJECT, "failed to parse array element. type=0x%x", (int)typeID);
|
|
return NULL;
|
|
}
|
|
if ([datatype shouldMergeData]) {
|
|
assert([tmpdict count] == 1);
|
|
[arr addObject: [tmpdict allValues][0]];
|
|
} else {
|
|
[arr addObject:tmpdict];
|
|
}
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
NSMutableDictionary *
|
|
parseKCDataContainer(kcdata_iter_t *iter_p, NSError **error)
|
|
{
|
|
kcdata_iter_t iter = *iter_p;
|
|
|
|
if (!kcdata_iter_container_valid(iter)) {
|
|
if (error)
|
|
*error = GEN_ERROR(KERN_INVALID_OBJECT, "invalid container");
|
|
return NULL;
|
|
}
|
|
uint64_t containerID = kcdata_iter_container_id(iter);
|
|
|
|
/* setup collection object for sub containers */
|
|
NSMutableDictionary * sub_containers = [[NSMutableDictionary alloc] init];
|
|
NSMutableDictionary * retval = [[NSMutableDictionary alloc] init];
|
|
NSMutableDictionary * container = [[NSMutableDictionary alloc] init];
|
|
|
|
KCDataType * tmptype;
|
|
uint32_t _t;
|
|
void * _d;
|
|
BOOL ok;
|
|
NSDictionary * tmpdict;
|
|
BOOL found_end = FALSE;
|
|
retval[KCDataTypeNameForID(kcdata_iter_container_type(iter))] = container;
|
|
|
|
iter = kcdata_iter_next(iter);
|
|
|
|
KCDATA_ITER_FOREACH(iter)
|
|
{
|
|
_t = kcdata_iter_type(iter);
|
|
_d = kcdata_iter_payload(iter);
|
|
if (_t == KCDATA_TYPE_CONTAINER_END) {
|
|
if (kcdata_iter_container_id(iter) != containerID) {
|
|
if (error)
|
|
*error = GEN_ERROR(KERN_INVALID_ARGUMENT, "container marker mismatch");
|
|
return NULL;
|
|
}
|
|
found_end = TRUE;
|
|
break;
|
|
}
|
|
|
|
if (_t == KCDATA_TYPE_ARRAY) {
|
|
tmpdict = parseKCDataArray(iter, error);
|
|
if (!tmpdict)
|
|
return NULL;
|
|
|
|
ok = mergedict(container, tmpdict, error);
|
|
if (!ok)
|
|
return NULL;
|
|
|
|
continue;
|
|
}
|
|
|
|
if (_t == KCDATA_TYPE_CONTAINER_BEGIN) {
|
|
NSString * subcontainerID = [NSString stringWithFormat:@"%llu", kcdata_iter_container_id(iter)];
|
|
tmpdict = parseKCDataContainer(&iter, error);
|
|
if (!tmpdict)
|
|
return NULL;
|
|
assert([tmpdict count] == 1);
|
|
for (NSString * k in [tmpdict keyEnumerator]) {
|
|
if (sub_containers[k] == nil) {
|
|
sub_containers[k] = [[NSMutableDictionary alloc] init];
|
|
}
|
|
if (sub_containers[k][subcontainerID] != nil) {
|
|
if (error)
|
|
*error = GEN_ERRORF(KERN_INVALID_OBJECT, "repeated container id: %@", subcontainerID);
|
|
return NULL;
|
|
}
|
|
sub_containers[k][subcontainerID] = tmpdict[k];
|
|
}
|
|
continue;
|
|
}
|
|
|
|
tmptype = getKCDataTypeForID(_t);
|
|
tmpdict = [tmptype parseData:_d ofLength:kcdata_iter_size(iter)];
|
|
if (!tmpdict) {
|
|
if (error)
|
|
*error = GEN_ERRORF(KERN_INVALID_OBJECT, "failed to parse. type=0x%x", (int)_t);
|
|
return NULL;
|
|
}
|
|
if (![tmptype shouldMergeData]) {
|
|
tmpdict = @{[tmptype name] : tmpdict};
|
|
}
|
|
ok = mergedict(container, tmpdict, error);
|
|
if (!ok)
|
|
return NULL;
|
|
}
|
|
|
|
if (!found_end) {
|
|
if (error)
|
|
*error = GEN_ERROR(KERN_INVALID_ARGUMENT, "missing container end");
|
|
return NULL;
|
|
}
|
|
|
|
ok = mergedict(container, sub_containers, error);
|
|
if (!ok)
|
|
return NULL;
|
|
|
|
*iter_p = iter;
|
|
return retval;
|
|
}
|
|
|
|
NSDictionary *
|
|
parseKCDataBuffer(void * dataBuffer, uint32_t size, NSError ** error)
|
|
{
|
|
if (dataBuffer == NULL) {
|
|
if (error)
|
|
*error = GEN_ERROR(KERN_INVALID_ARGUMENT, "buffer is null");
|
|
return NULL;
|
|
}
|
|
|
|
uint32_t _type = (size >= sizeof(uint32_t)) ? *(uint32_t*)dataBuffer : 0;
|
|
uint32_t _size = 0;
|
|
uint64_t _flags = 0;
|
|
void * _datap = NULL;
|
|
KCDataType * kcd_type = NULL;
|
|
NSString * rootKey = NULL;
|
|
uint32_t rootType = _type;
|
|
BOOL ok;
|
|
|
|
/* validate begin tag and get root key */
|
|
switch (_type) {
|
|
case KCDATA_BUFFER_BEGIN_CRASHINFO:
|
|
rootKey = @"kcdata_crashinfo";
|
|
break;
|
|
case KCDATA_BUFFER_BEGIN_STACKSHOT:
|
|
rootKey = @"kcdata_stackshot";
|
|
break;
|
|
case KCDATA_BUFFER_BEGIN_DELTA_STACKSHOT:
|
|
rootKey = @"kcdata_delta_stackshot";
|
|
break;
|
|
case KCDATA_BUFFER_BEGIN_OS_REASON:
|
|
rootKey = @"kcdata_reason";
|
|
break;
|
|
case KCDATA_BUFFER_BEGIN_XNUPOST_CONFIG:
|
|
rootKey = @"xnupost_testconfig";
|
|
break;
|
|
default: {
|
|
if (error)
|
|
*error = GEN_ERROR(KERN_INVALID_VALUE, "invalid magic number");
|
|
return NULL;
|
|
break;
|
|
}
|
|
}
|
|
assert(rootKey != NULL);
|
|
|
|
kcdata_iter_t iter = kcdata_iter(dataBuffer, size);
|
|
|
|
if (!kcdata_iter_valid(iter)) {
|
|
if (error) {
|
|
*error = GEN_ERROR(KERN_INVALID_OBJECT, "initial item is invalid");
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
NSMutableDictionary * rootObject = [NSMutableDictionary dictionary];
|
|
NSDictionary * retval = [NSMutableDictionary dictionaryWithObject:rootObject forKey:rootKey];
|
|
|
|
/* iterate over each kcdata item */
|
|
KCDATA_ITER_FOREACH(iter)
|
|
{
|
|
_type = kcdata_iter_type(iter);
|
|
_size = kcdata_iter_size(iter);
|
|
_flags = kcdata_iter_flags(iter);
|
|
_datap = kcdata_iter_payload(iter);
|
|
|
|
if (_type == rootType)
|
|
continue;
|
|
|
|
if (_type == KCDATA_TYPE_ARRAY) {
|
|
NSDictionary * dict = parseKCDataArray(iter, error);
|
|
if (!dict)
|
|
return nil;
|
|
|
|
ok = mergedict(rootObject, dict, error);
|
|
if (!ok)
|
|
return NULL;
|
|
|
|
continue;
|
|
}
|
|
|
|
if (_type == KCDATA_TYPE_CONTAINER_BEGIN) {
|
|
NSString * containerID = [NSString stringWithFormat:@"%llu", kcdata_iter_container_id(iter)];
|
|
NSMutableDictionary *container = parseKCDataContainer(&iter, error);
|
|
if (!container)
|
|
return nil;
|
|
assert([container count] == 1);
|
|
for (NSString * k in [container keyEnumerator]) {
|
|
if (rootObject[k] == nil) {
|
|
rootObject[k] = [[NSMutableDictionary alloc] init];
|
|
}
|
|
if (rootObject[k][containerID] != nil) {
|
|
if (error)
|
|
*error = GEN_ERRORF(KERN_INVALID_OBJECT, "repeated container id: %@", containerID);
|
|
return NULL;
|
|
}
|
|
rootObject[k][containerID] = container[k];
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (_type == KCDATA_TYPE_TYPEDEFINTION) {
|
|
KCDataType *new_type = getTypeFromTypeDef((struct kcdata_type_definition *)_datap);
|
|
if (new_type != NULL) {
|
|
setKCDataTypeForID([new_type typeID], new_type);
|
|
kcd_type = getKCDataTypeForID(_type);
|
|
NSDictionary * tmpdict = [kcd_type parseData:_datap ofLength:_size];
|
|
if (!tmpdict) {
|
|
if (error)
|
|
*error = GEN_ERRORF(KERN_INVALID_OBJECT, "failed to parse. type=0x%x", (int)_type);
|
|
return NULL;
|
|
}
|
|
NSString *k = [NSString stringWithFormat:@"typedef[%@]", [new_type name]];
|
|
rootObject[k] = tmpdict;
|
|
}else {
|
|
if (error)
|
|
*error = GEN_ERRORF(KERN_INVALID_OBJECT, "Failed to parse type definition for type %u", _type);
|
|
return NULL;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
kcd_type = getKCDataTypeForID(_type);
|
|
NSDictionary * tmpdict = [kcd_type parseData:_datap ofLength:_size];
|
|
if (!tmpdict) {
|
|
if (error)
|
|
*error = GEN_ERRORF(KERN_INVALID_OBJECT, "failed to parse. type=0x%x", (int)_type);
|
|
return NULL;
|
|
}
|
|
if (![kcd_type shouldMergeData]) {
|
|
tmpdict = @{[kcd_type name] : tmpdict};
|
|
}
|
|
ok = mergedict(rootObject, tmpdict, error);
|
|
if (!ok)
|
|
return NULL;
|
|
}
|
|
|
|
if (KCDATA_ITER_FOREACH_FAILED(iter)) {
|
|
retval = nil;
|
|
if (error) {
|
|
*error = GEN_ERROR(KERN_INVALID_OBJECT, "invalid item or missing buffer end marker");
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|