/**
* g_node_copy_deep:
* @node: a #GNode
* @copy_func: the function which is called to copy the data inside each node,
* or %NULL to use the original data.
* @data: data to pass to @copy_func
*
* Recursively copies a #GNode and its data.
*
* Return value: a new #GNode containing copies of the data in @node.
*
* Since: 2.4
**/
GNode*
g_node_copy_deep (GNode *node,
GCopyFunc copy_func,
gpointer data)
{
GNode *new_node = NULL;
if (copy_func == NULL)
return g_node_copy (node);
if (node)
{
GNode *child, *new_child;
new_node = g_node_new (copy_func (node->data, data));
for (child = g_node_last_child (node); child; child = child->prev)
{
new_child = g_node_copy_deep (child, copy_func, data);
g_node_prepend (new_node, new_child);
}
}
return new_node;
}
void plist_from_bin(const char *plist_bin, uint32_t length, plist_t * plist)
{
char *trailer = NULL;
uint8_t offset_size = 0;
uint8_t dict_param_size = 0;
uint64_t num_objects = 0;
uint64_t root_object = 0;
uint64_t offset_table_index = 0;
plist_t *nodeslist = NULL;
uint64_t i = 0;
uint64_t current_offset = 0;
char *offset_table = NULL;
uint32_t j = 0, str_i = 0, str_j = 0;
uint32_t index1 = 0, index2 = 0;
//first check we have enough data
if (!(length >= BPLIST_MAGIC_SIZE + BPLIST_VERSION_SIZE + BPLIST_TRL_SIZE))
return;
//check that plist_bin in actually a plist
if (memcmp(plist_bin, BPLIST_MAGIC, BPLIST_MAGIC_SIZE) != 0)
return;
//check for known version
if (memcmp(plist_bin + BPLIST_MAGIC_SIZE, BPLIST_VERSION, BPLIST_VERSION_SIZE) != 0)
return;
//now parse trailer
trailer = (char *) (plist_bin + (length - BPLIST_TRL_SIZE));
offset_size = trailer[BPLIST_TRL_OFFSIZE_IDX];
dict_param_size = trailer[BPLIST_TRL_PARMSIZE_IDX];
num_objects = be64dec(trailer + BPLIST_TRL_NUMOBJ_IDX);
root_object = be64dec(trailer + BPLIST_TRL_ROOTOBJ_IDX);
offset_table_index = be64dec(trailer + BPLIST_TRL_OFFTAB_IDX);
if (num_objects == 0)
return;
//allocate serialized array of nodes
nodeslist = (plist_t *) malloc(sizeof(plist_t) * num_objects);
if (!nodeslist)
return;
//parse serialized nodes
offset_table = (char *) (plist_bin + offset_table_index);
for (i = 0; i < num_objects; i++)
{
char *obj = NULL;
current_offset = UINT_TO_HOST(offset_table + i * offset_size, offset_size);
obj = (char *) (plist_bin + current_offset);
nodeslist[i] = parse_bin_node(obj, dict_param_size, &obj);
}
//setup children for structured types
for (i = 0; i < num_objects; i++)
{
plist_data_t data = plist_get_data(nodeslist[i]);
switch (data->type)
{
case PLIST_DICT:
for (j = 0; j < data->length; j++)
{
str_i = j * dict_param_size;
str_j = (j + data->length) * dict_param_size;
index1 = UINT_TO_HOST(data->buff + str_i, dict_param_size);
index2 = UINT_TO_HOST(data->buff + str_j, dict_param_size);
//first one is actually a key
plist_get_data(nodeslist[index1])->type = PLIST_KEY;
if (index1 < num_objects)
{
if (G_NODE_IS_ROOT(nodeslist[index1]))
g_node_append(nodeslist[i], nodeslist[index1]);
else
g_node_append(nodeslist[i], g_node_copy_deep(nodeslist[index1], copy_plist_data, NULL));
}
if (index2 < num_objects)
{
if (G_NODE_IS_ROOT(nodeslist[index2]))
g_node_append(nodeslist[i], nodeslist[index2]);
else
g_node_append(nodeslist[i], g_node_copy_deep(nodeslist[index2], copy_plist_data, NULL));
}
}
free(data->buff);
break;
case PLIST_ARRAY:
for (j = 0; j < data->length; j++)
{
str_j = j * dict_param_size;
index1 = UINT_TO_HOST(data->buff + str_j, dict_param_size);
if (index1 < num_objects)
{
if (G_NODE_IS_ROOT(nodeslist[index1]))
g_node_append(nodeslist[i], nodeslist[index1]);
else
g_node_append(nodeslist[i], g_node_copy_deep(nodeslist[index1], copy_plist_data, NULL));
}
}
free(data->buff);
break;
default:
break;
}
}
*plist = nodeslist[root_object];
free(nodeslist);
}
GNode *
glade_model_data_tree_copy (GNode * node)
{
return g_node_copy_deep (node, (GCopyFunc) glade_model_data_copy, NULL);
}
