summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/Array.cpp52
-rw-r--r--src/Boolean.cpp6
-rw-r--r--src/Data.cpp6
-rw-r--r--src/Date.cpp6
-rw-r--r--src/Dictionary.cpp78
-rw-r--r--src/Integer.cpp6
-rw-r--r--src/Node.cpp69
-rw-r--r--src/Real.cpp6
-rw-r--r--src/String.cpp6
-rw-r--r--src/Structure.cpp10
-rw-r--r--src/Utils.cpp66
-rw-r--r--src/bplist.c1445
-rw-r--r--src/plist.c1212
-rw-r--r--src/plist.h30
-rw-r--r--src/xplist.c564
15 files changed, 1838 insertions, 1724 deletions
diff --git a/src/Array.cpp b/src/Array.cpp
index dbb1239..bdd26e1 100644
--- a/src/Array.cpp
+++ b/src/Array.cpp
@@ -7,15 +7,15 @@
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
@@ -37,7 +37,7 @@ Array::Array(plist_t node, Node* parent) : Structure(parent)
for (uint32_t i = 0; i < size; i++)
{
- plist_t subnode = plist_array_get_item(_node, i);
+ plist_t subnode = plist_array_get_item(_node, i);
_array.push_back( Utils::FromPlist(subnode, this) );
}
}
@@ -50,7 +50,7 @@ Array::Array(PList::Array& a) : Structure()
for (uint32_t i = 0; i < size; i++)
{
- plist_t subnode = plist_array_get_item(_node, i);
+ plist_t subnode = plist_array_get_item(_node, i);
_array.push_back( Utils::FromPlist(subnode, this) );
}
}
@@ -60,7 +60,7 @@ Array& Array::operator=(PList::Array& a)
plist_free(_node);
for (unsigned int it = 0; it < _array.size(); it++)
{
- delete _array.at(it);
+ delete _array.at(it);
}
_array.clear();
@@ -69,7 +69,7 @@ Array& Array::operator=(PList::Array& a)
for (uint32_t i = 0; i < size; i++)
{
- plist_t subnode = plist_array_get_item(_node, i);
+ plist_t subnode = plist_array_get_item(_node, i);
_array.push_back( Utils::FromPlist(subnode, this) );
}
return *this;
@@ -77,11 +77,11 @@ Array& Array::operator=(PList::Array& a)
Array::~Array()
{
- for (unsigned int it = 0; it < _array.size(); it++)
- {
- delete (_array.at(it));
- }
- _array.clear();
+ for (unsigned int it = 0; it < _array.size(); it++)
+ {
+ delete (_array.at(it));
+ }
+ _array.clear();
}
Node* Array::Clone()
@@ -98,10 +98,10 @@ void Array::Append(Node* node)
{
if (node)
{
- Node* clone = node->Clone();
+ Node* clone = node->Clone();
clone->SetParent(this);
- plist_array_append_item(_node, clone->GetPlist());
- _array.push_back(clone);
+ plist_array_append_item(_node, clone->GetPlist());
+ _array.push_back(clone);
}
}
@@ -109,12 +109,12 @@ void Array::Insert(Node* node, unsigned int pos)
{
if (node)
{
- Node* clone = node->Clone();
+ Node* clone = node->Clone();
clone->SetParent(this);
- plist_array_insert_item(_node, clone->GetPlist(), pos);
- std::vector<Node*>::iterator it = _array.begin();
- it += pos;
- _array.insert(it, clone);
+ plist_array_insert_item(_node, clone->GetPlist(), pos);
+ std::vector<Node*>::iterator it = _array.begin();
+ it += pos;
+ _array.insert(it, clone);
}
}
@@ -122,12 +122,12 @@ void Array::Remove(Node* node)
{
if (node)
{
- uint32_t pos = plist_array_get_item_index(node->GetPlist());
- plist_array_remove_item(_node, pos);
- std::vector<Node*>::iterator it = _array.begin();
- it += pos;
- _array.erase(it);
- delete node;
+ uint32_t pos = plist_array_get_item_index(node->GetPlist());
+ plist_array_remove_item(_node, pos);
+ std::vector<Node*>::iterator it = _array.begin();
+ it += pos;
+ _array.erase(it);
+ delete node;
}
}
diff --git a/src/Boolean.cpp b/src/Boolean.cpp
index dfa96ca..e58472f 100644
--- a/src/Boolean.cpp
+++ b/src/Boolean.cpp
@@ -7,15 +7,15 @@
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
diff --git a/src/Data.cpp b/src/Data.cpp
index 02ce983..df5c1c7 100644
--- a/src/Data.cpp
+++ b/src/Data.cpp
@@ -7,15 +7,15 @@
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
diff --git a/src/Date.cpp b/src/Date.cpp
index cb817d9..2430184 100644
--- a/src/Date.cpp
+++ b/src/Date.cpp
@@ -7,15 +7,15 @@
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
diff --git a/src/Dictionary.cpp b/src/Dictionary.cpp
index 72307f1..fedce2e 100644
--- a/src/Dictionary.cpp
+++ b/src/Dictionary.cpp
@@ -7,15 +7,15 @@
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
@@ -41,11 +41,11 @@ Dictionary::Dictionary(plist_t node, Node* parent) : Structure(parent)
while (subnode)
{
_map[std::string(key)] = Utils::FromPlist(subnode, this);
-
- subnode = NULL;
- free(key);
- key = NULL;
- plist_dict_next_item(_node, it, &key, &subnode);
+
+ subnode = NULL;
+ free(key);
+ key = NULL;
+ plist_dict_next_item(_node, it, &key, &subnode);
}
free(it);
}
@@ -54,8 +54,8 @@ Dictionary::Dictionary(PList::Dictionary& d) : Structure()
{
for (Dictionary::iterator it = _map.begin(); it != _map.end(); it++)
{
- plist_free(it->second->GetPlist());
- delete it->second;
+ plist_free(it->second->GetPlist());
+ delete it->second;
}
_map.clear();
@@ -69,11 +69,11 @@ Dictionary::Dictionary(PList::Dictionary& d) : Structure()
while (subnode)
{
_map[std::string(key)] = Utils::FromPlist(subnode, this);
-
- subnode = NULL;
- free(key);
- key = NULL;
- plist_dict_next_item(_node, it, NULL, &subnode);
+
+ subnode = NULL;
+ free(key);
+ key = NULL;
+ plist_dict_next_item(_node, it, NULL, &subnode);
}
free(it);
}
@@ -82,8 +82,8 @@ Dictionary& Dictionary::operator=(PList::Dictionary& d)
{
for (Dictionary::iterator it = _map.begin(); it != _map.end(); it++)
{
- plist_free(it->second->GetPlist());
- delete it->second;
+ plist_free(it->second->GetPlist());
+ delete it->second;
}
_map.clear();
@@ -97,11 +97,11 @@ Dictionary& Dictionary::operator=(PList::Dictionary& d)
while (subnode)
{
_map[std::string(key)] = Utils::FromPlist(subnode, this);
-
- subnode = NULL;
- free(key);
- key = NULL;
- plist_dict_next_item(_node, it, NULL, &subnode);
+
+ subnode = NULL;
+ free(key);
+ key = NULL;
+ plist_dict_next_item(_node, it, NULL, &subnode);
}
free(it);
return *this;
@@ -111,8 +111,8 @@ Dictionary::~Dictionary()
{
for (Dictionary::iterator it = _map.begin(); it != _map.end(); it++)
{
- plist_free(it->second->GetPlist());
- delete it->second;
+ plist_free(it->second->GetPlist());
+ delete it->second;
}
_map.clear();
}
@@ -146,12 +146,12 @@ Dictionary::iterator Dictionary::Insert(const std::string& key, Node* node)
{
if (node)
{
- Node* clone = node->Clone();
+ Node* clone = node->Clone();
clone->SetParent(this);
- plist_dict_insert_item(_node, key.c_str(), clone->GetPlist());
- delete _map[key];
- _map[key] = clone;
- return _map.find(key);
+ plist_dict_insert_item(_node, key.c_str(), clone->GetPlist());
+ delete _map[key];
+ _map[key] = clone;
+ return _map.find(key);
}
return iterator(NULL);
}
@@ -160,21 +160,21 @@ void Dictionary::Remove(Node* node)
{
if (node)
{
- char* key = NULL;
- plist_dict_get_item_key(node->GetPlist(), &key);
- plist_dict_remove_item(_node, key);
- std::string skey = key;
- free(key);
- _map.erase(skey);
- delete node;
+ char* key = NULL;
+ plist_dict_get_item_key(node->GetPlist(), &key);
+ plist_dict_remove_item(_node, key);
+ std::string skey = key;
+ free(key);
+ _map.erase(skey);
+ delete node;
}
}
void Dictionary::Remove(const std::string& key)
{
- plist_dict_remove_item(_node, key.c_str());
- delete _map[key];
- _map.erase(key);
+ plist_dict_remove_item(_node, key.c_str());
+ delete _map[key];
+ _map.erase(key);
}
};
diff --git a/src/Integer.cpp b/src/Integer.cpp
index 4c8a825..fed03f6 100644
--- a/src/Integer.cpp
+++ b/src/Integer.cpp
@@ -7,15 +7,15 @@
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
diff --git a/src/Node.cpp b/src/Node.cpp
index c6a5b51..8ed3c6a 100644
--- a/src/Node.cpp
+++ b/src/Node.cpp
@@ -7,15 +7,15 @@
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
@@ -36,36 +36,37 @@ Node::Node(plist_t node, Node* parent) : _node(node), _parent(parent)
Node::Node(plist_type type, Node* parent) : _parent(parent)
{
_node = NULL;
-
- switch(type) {
- case PLIST_BOOLEAN:
- _node = plist_new_bool(0);
- break;
- case PLIST_UINT:
- _node = plist_new_uint(0);
- break;
- case PLIST_REAL:
- _node = plist_new_real(0.);
- break;
- case PLIST_STRING:
- _node = plist_new_string("");
- break;
- case PLIST_DATA:
- _node = plist_new_data(NULL,0);
- break;
- case PLIST_DATE:
- _node = plist_new_date(0,0);
- break;
- case PLIST_ARRAY:
- _node = plist_new_array();
- break;
- case PLIST_DICT:
- _node = plist_new_dict();
- break;
- case PLIST_KEY:
- case PLIST_NONE:
- default:
- break;
+
+ switch (type)
+ {
+ case PLIST_BOOLEAN:
+ _node = plist_new_bool(0);
+ break;
+ case PLIST_UINT:
+ _node = plist_new_uint(0);
+ break;
+ case PLIST_REAL:
+ _node = plist_new_real(0.);
+ break;
+ case PLIST_STRING:
+ _node = plist_new_string("");
+ break;
+ case PLIST_DATA:
+ _node = plist_new_data(NULL,0);
+ break;
+ case PLIST_DATE:
+ _node = plist_new_date(0,0);
+ break;
+ case PLIST_ARRAY:
+ _node = plist_new_array();
+ break;
+ case PLIST_DICT:
+ _node = plist_new_dict();
+ break;
+ case PLIST_KEY:
+ case PLIST_NONE:
+ default:
+ break;
}
}
@@ -80,7 +81,7 @@ plist_type Node::GetType()
{
if (_node)
{
- return plist_get_node_type(_node);
+ return plist_get_node_type(_node);
}
return PLIST_NONE;
}
diff --git a/src/Real.cpp b/src/Real.cpp
index 512c44e..768d07c 100644
--- a/src/Real.cpp
+++ b/src/Real.cpp
@@ -7,15 +7,15 @@
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
diff --git a/src/String.cpp b/src/String.cpp
index 3ae158e..bf65605 100644
--- a/src/String.cpp
+++ b/src/String.cpp
@@ -7,15 +7,15 @@
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
diff --git a/src/Structure.cpp b/src/Structure.cpp
index 5c7dc9a..872d396 100644
--- a/src/Structure.cpp
+++ b/src/Structure.cpp
@@ -7,15 +7,15 @@
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
@@ -41,11 +41,11 @@ uint32_t Structure::GetSize()
plist_type type = plist_get_node_type(_node);
if (type == PLIST_ARRAY)
{
- size = plist_array_get_size(_node);
+ size = plist_array_get_size(_node);
}
else if (type == PLIST_DICT)
{
- size = plist_dict_get_size(_node);
+ size = plist_dict_get_size(_node);
}
return size;
}
diff --git a/src/Utils.cpp b/src/Utils.cpp
index df003e7..cb6da5e 100644
--- a/src/Utils.cpp
+++ b/src/Utils.cpp
@@ -7,15 +7,15 @@
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
@@ -38,36 +38,36 @@ Node* Utils::FromPlist(plist_t node, Node* parent)
if (node)
{
plist_type type = plist_get_node_type(node);
- switch(type)
- {
- case PLIST_DICT:
- ret = new Dictionary(node, parent);
- break;
- case PLIST_ARRAY:
- ret = new Array(node, parent);
- break;
- case PLIST_BOOLEAN:
- ret = new Boolean(node, parent);
- break;
- case PLIST_UINT:
- ret = new Integer(node, parent);
- break;
- case PLIST_REAL:
- ret = new Real(node, parent);
- break;
- case PLIST_STRING:
- ret = new String(node, parent);
- break;
- case PLIST_DATE:
- ret = new Date(node, parent);
- break;
- case PLIST_DATA:
- ret = new Data(node, parent);
- break;
- default:
- plist_free(node);
- break;
- }
+ switch (type)
+ {
+ case PLIST_DICT:
+ ret = new Dictionary(node, parent);
+ break;
+ case PLIST_ARRAY:
+ ret = new Array(node, parent);
+ break;
+ case PLIST_BOOLEAN:
+ ret = new Boolean(node, parent);
+ break;
+ case PLIST_UINT:
+ ret = new Integer(node, parent);
+ break;
+ case PLIST_REAL:
+ ret = new Real(node, parent);
+ break;
+ case PLIST_STRING:
+ ret = new String(node, parent);
+ break;
+ case PLIST_DATE:
+ ret = new Date(node, parent);
+ break;
+ case PLIST_DATA:
+ ret = new Data(node, parent);
+ break;
+ default:
+ plist_free(node);
+ break;
+ }
}
return ret;
}
diff --git a/src/bplist.c b/src/bplist.c
index 6e3007a..d37ed7a 100644
--- a/src/bplist.c
+++ b/src/bplist.c
@@ -8,15 +8,15 @@
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
@@ -44,46 +44,48 @@
#define BPLIST_TRL_ROOTOBJ_IDX 10
#define BPLIST_TRL_OFFTAB_IDX 18
-enum {
- BPLIST_NULL = 0x00,
- BPLIST_FALSE = 0x08,
- BPLIST_TRUE = 0x09,
- BPLIST_FILL = 0x0F, /* will be used for length grabbing */
- BPLIST_UINT = 0x10,
- BPLIST_REAL = 0x20,
- BPLIST_DATE = 0x30,
- BPLIST_DATA = 0x40,
- BPLIST_STRING = 0x50,
- BPLIST_UNICODE = 0x60,
- BPLIST_UID = 0x70,
- BPLIST_ARRAY = 0xA0,
- BPLIST_SET = 0xC0,
- BPLIST_DICT = 0xD0,
- BPLIST_MASK = 0xF0
+enum
+{
+ BPLIST_NULL = 0x00,
+ BPLIST_FALSE = 0x08,
+ BPLIST_TRUE = 0x09,
+ BPLIST_FILL = 0x0F, /* will be used for length grabbing */
+ BPLIST_UINT = 0x10,
+ BPLIST_REAL = 0x20,
+ BPLIST_DATE = 0x30,
+ BPLIST_DATA = 0x40,
+ BPLIST_STRING = 0x50,
+ BPLIST_UNICODE = 0x60,
+ BPLIST_UID = 0x70,
+ BPLIST_ARRAY = 0xA0,
+ BPLIST_SET = 0xC0,
+ BPLIST_DICT = 0xD0,
+ BPLIST_MASK = 0xF0
};
static void byte_convert(uint8_t * address, size_t size)
{
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
- uint8_t i = 0, j = 0;
- uint8_t tmp = 0;
-
- for (i = 0; i < (size / 2); i++) {
- tmp = address[i];
- j = ((size - 1) + 0) - i;
- address[i] = address[j];
- address[j] = tmp;
- }
+ uint8_t i = 0, j = 0;
+ uint8_t tmp = 0;
+
+ for (i = 0; i < (size / 2); i++)
+ {
+ tmp = address[i];
+ j = ((size - 1) + 0) - i;
+ address[i] = address[j];
+ address[j] = tmp;
+ }
#endif
}
static uint32_t uint24_from_be(char *buff)
{
- uint32_t ret = 0;
- char *tmp = (char *) &ret;
- memcpy(tmp + 1, buff, 3 * sizeof(char));
- byte_convert(tmp, sizeof(uint32_t));
- return ret;
+ uint32_t ret = 0;
+ char *tmp = (char *) &ret;
+ memcpy(tmp + 1, buff, 3 * sizeof(char));
+ byte_convert(tmp, sizeof(uint32_t));
+ return ret;
}
#define UINT_TO_HOST(x, n) \
@@ -106,787 +108,822 @@ static uint32_t uint24_from_be(char *buff)
static plist_t parse_uint_node(char *bnode, uint8_t size, char **next_object)
{
- plist_data_t data = plist_new_plist_data();
-
- size = 1 << size; // make length less misleading
- switch (size) {
- case sizeof(uint8_t):
- case sizeof(uint16_t):
- case sizeof(uint32_t):
- case sizeof(uint64_t):
- memcpy(&data->intval, bnode, size);
- data->intval = UINT_TO_HOST(&data->intval, size);
- break;
- default:
- free(data);
- return NULL;
- };
-
- *next_object = bnode + size;
- data->type = PLIST_UINT;
- data->length = sizeof(uint64_t);
-
- return g_node_new(data);
+ plist_data_t data = plist_new_plist_data();
+
+ size = 1 << size; // make length less misleading
+ switch (size)
+ {
+ case sizeof(uint8_t):
+ case sizeof(uint16_t):
+ case sizeof(uint32_t):
+ case sizeof(uint64_t):
+ memcpy(&data->intval, bnode, size);
+ data->intval = UINT_TO_HOST(&data->intval, size);
+ break;
+ default:
+ free(data);
+ return NULL;
+ };
+
+ *next_object = bnode + size;
+ data->type = PLIST_UINT;
+ data->length = sizeof(uint64_t);
+
+ return g_node_new(data);
}
static plist_t parse_real_node(char *bnode, uint8_t size)
{
- plist_data_t data = plist_new_plist_data();
- float floatval = 0.0;
-
- size = 1 << size; // make length less misleading
- switch (size) {
- case sizeof(float):
- floatval = *(float *) bnode;
- byte_convert((uint8_t *) & floatval, sizeof(float));
- data->realval = floatval;
- break;
- case sizeof(double):
- data->realval = *(double *) bnode;
- byte_convert((uint8_t *) & (data->realval), sizeof(double));
- break;
- default:
- free(data);
- return NULL;
- }
- data->type = PLIST_REAL;
- data->length = sizeof(double);
-
- return g_node_new(data);
+ plist_data_t data = plist_new_plist_data();
+ float floatval = 0.0;
+
+ size = 1 << size; // make length less misleading
+ switch (size)
+ {
+ case sizeof(float):
+ floatval = *(float *) bnode;
+ byte_convert((uint8_t *) & floatval, sizeof(float));
+ data->realval = floatval;
+ break;
+ case sizeof(double):
+ data->realval = *(double *) bnode;
+ byte_convert((uint8_t *) & (data->realval), sizeof(double));
+ break;
+ default:
+ free(data);
+ return NULL;
+ }
+ data->type = PLIST_REAL;
+ data->length = sizeof(double);
+
+ return g_node_new(data);
}
static plist_t parse_date_node(char *bnode, uint8_t size)
{
- plist_t node = parse_real_node(bnode, size);
- plist_data_t data = plist_get_data(node);
+ plist_t node = parse_real_node(bnode, size);
+ plist_data_t data = plist_get_data(node);
- double time_real = data->realval;
- data->timeval.tv_sec = (glong) time_real;
- data->timeval.tv_usec = (time_real - (glong) time_real) * G_USEC_PER_SEC;
- data->type = PLIST_DATE;
- data->length = sizeof(GTimeVal);
+ double time_real = data->realval;
+ data->timeval.tv_sec = (glong) time_real;
+ data->timeval.tv_usec = (time_real - (glong) time_real) * G_USEC_PER_SEC;
+ data->type = PLIST_DATE;
+ data->length = sizeof(GTimeVal);
- return node;
+ return node;
}
static plist_t parse_string_node(char *bnode, uint64_t size)
{
- plist_data_t data = plist_new_plist_data();
+ plist_data_t data = plist_new_plist_data();
- data->type = PLIST_STRING;
- data->strval = (char *) malloc(sizeof(char) * (size + 1));
- memcpy(data->strval, bnode, size);
- data->strval[size] = '\0';
- data->length = strlen(data->strval);
+ data->type = PLIST_STRING;
+ data->strval = (char *) malloc(sizeof(char) * (size + 1));
+ memcpy(data->strval, bnode, size);
+ data->strval[size] = '\0';
+ data->length = strlen(data->strval);
- return g_node_new(data);
+ return g_node_new(data);
}
static plist_t parse_unicode_node(char *bnode, uint64_t size)
{
- plist_data_t data = plist_new_plist_data();
- uint64_t i = 0;
- gunichar2 *unicodestr = NULL;
- gchar *tmpstr = NULL;
- int type = 0;
- glong items_read = 0;
- glong items_written = 0;
- GError *error = NULL;
-
- data->type = PLIST_STRING;
- unicodestr = (gunichar2 *) malloc(sizeof(gunichar2) * size);
- memcpy(unicodestr, bnode, sizeof(gunichar2) * size);
- for (i = 0; i < size; i++)
- byte_convert((uint8_t *) (unicodestr + i), sizeof(gunichar2));
-
- tmpstr = g_utf16_to_utf8(unicodestr, size, &items_read, &items_written, &error);
- free(unicodestr);
-
- data->type = PLIST_STRING;
- data->strval = (char *) malloc(sizeof(char) * (items_written + 1));
- memcpy(data->strval, tmpstr, items_written);
- data->strval[items_written] = '\0';
- data->length = strlen(data->strval);
- g_free(tmpstr);
- return g_node_new(data);
+ plist_data_t data = plist_new_plist_data();
+ uint64_t i = 0;
+ gunichar2 *unicodestr = NULL;
+ gchar *tmpstr = NULL;
+ int type = 0;
+ glong items_read = 0;
+ glong items_written = 0;
+ GError *error = NULL;
+
+ data->type = PLIST_STRING;
+ unicodestr = (gunichar2 *) malloc(sizeof(gunichar2) * size);
+ memcpy(unicodestr, bnode, sizeof(gunichar2) * size);
+ for (i = 0; i < size; i++)
+ byte_convert((uint8_t *) (unicodestr + i), sizeof(gunichar2));
+
+ tmpstr = g_utf16_to_utf8(unicodestr, size, &items_read, &items_written, &error);
+ free(unicodestr);
+
+ data->type = PLIST_STRING;
+ data->strval = (char *) malloc(sizeof(char) * (items_written + 1));
+ memcpy(data->strval, tmpstr, items_written);
+ data->strval[items_written] = '\0';
+ data->length = strlen(data->strval);
+ g_free(tmpstr);
+ return g_node_new(data);
}
static plist_t parse_data_node(char *bnode, uint64_t size)
{
- plist_data_t data = plist_new_plist_data();
+ plist_data_t data = plist_new_plist_data();
- data->type = PLIST_DATA;
- data->length = size;
- data->buff = (uint8_t *) malloc(sizeof(uint8_t) * size);
- memcpy(data->buff, bnode, sizeof(uint8_t) * size);
+ data->type = PLIST_DATA;
+ data->length = size;
+ data->buff = (uint8_t *) malloc(sizeof(uint8_t) * size);
+ memcpy(data->buff, bnode, sizeof(uint8_t) * size);
- return g_node_new(data);
+ return g_node_new(data);
}
static plist_t parse_dict_node(char *bnode, uint64_t size, uint32_t ref_size)
{
- plist_data_t data = plist_new_plist_data();
+ plist_data_t data = plist_new_plist_data();
- data->type = PLIST_DICT;
- data->length = size;
- data->buff = (uint8_t *) malloc(sizeof(uint8_t) * size * ref_size * 2);
- memcpy(data->buff, bnode, sizeof(uint8_t) * size * ref_size * 2);
+ data->type = PLIST_DICT;
+ data->length = size;
+ data->buff = (uint8_t *) malloc(sizeof(uint8_t) * size * ref_size * 2);
+ memcpy(data->buff, bnode, sizeof(uint8_t) * size * ref_size * 2);
- return g_node_new(data);
+ return g_node_new(data);
}
static plist_t parse_array_node(char *bnode, uint64_t size, uint32_t ref_size)
{
- plist_data_t data = plist_new_plist_data();
+ plist_data_t data = plist_new_plist_data();
- data->type = PLIST_ARRAY;
- data->length = size;
- data->buff = (uint8_t *) malloc(sizeof(uint8_t) * size * ref_size);
- memcpy(data->buff, bnode, sizeof(uint8_t) * size * ref_size);
+ data->type = PLIST_ARRAY;
+ data->length = size;
+ data->buff = (uint8_t *) malloc(sizeof(uint8_t) * size * ref_size);
+ memcpy(data->buff, bnode, sizeof(uint8_t) * size * ref_size);
- return g_node_new(data);
+ return g_node_new(data);
}
static plist_t parse_bin_node(char *object, uint8_t dict_size, char **next_object)
{
- uint16_t type = 0;
- uint64_t size = 0;
-
- if (!object)
- return NULL;
-
- type = (*object) & 0xF0;
- size = (*object) & 0x0F;
- object++;
-
- switch (type) {
-
- case BPLIST_NULL:
- switch (size) {
-
- case BPLIST_TRUE:
- {
- plist_data_t data = plist_new_plist_data();
- data->type = PLIST_BOOLEAN;
- data->boolval = TRUE;
- data->length = 1;
- return g_node_new(data);
- }
-
- case BPLIST_FALSE:
- {
- plist_data_t data = plist_new_plist_data();
- data->type = PLIST_BOOLEAN;
- data->boolval = FALSE;
- data->length = 1;
- return g_node_new(data);
- }
-
- case BPLIST_NULL:
- default:
- return NULL;
- }
-
- case BPLIST_UINT:
- return parse_uint_node(object, size, next_object);
-
- case BPLIST_REAL:
- return parse_real_node(object, size);
-
- case BPLIST_DATE:
- if (3 != size)
- return NULL;
- else
- return parse_date_node(object, size);
-
- case BPLIST_DATA:
- if (0x0F == size) {
- plist_t size_node = parse_bin_node(object, dict_size, &object);
- if (plist_get_node_type(size_node) != PLIST_UINT)
- return NULL;
- plist_get_uint_val(size_node, &size);
- plist_free(size_node);
- }
- return parse_data_node(object, size);
-
- case BPLIST_STRING:
- if (0x0F == size) {
- plist_t size_node = parse_bin_node(object, dict_size, &object);
- if (plist_get_node_type(size_node) != PLIST_UINT)
- return NULL;
- plist_get_uint_val(size_node, &size);
- plist_free(size_node);
- }
- return parse_string_node(object, size);
-
- case BPLIST_UNICODE:
- if (0x0F == size) {
- plist_t size_node = parse_bin_node(object, dict_size, &object);
- if (plist_get_node_type(size_node) != PLIST_UINT)
- return NULL;
- plist_get_uint_val(size_node, &size);
- plist_free(size_node);
- }
- return parse_unicode_node(object, size);
-
- case BPLIST_UID:
- case BPLIST_ARRAY:
- if (0x0F == size) {
- plist_t size_node = parse_bin_node(object, dict_size, &object);
- if (plist_get_node_type(size_node) != PLIST_UINT)
- return NULL;
- plist_get_uint_val(size_node, &size);
- plist_free(size_node);
- }
- return parse_array_node(object, size, dict_size);
-
- case BPLIST_SET:
- case BPLIST_DICT:
- if (0x0F == size) {
- plist_t size_node = parse_bin_node(object, dict_size, &object);
- if (plist_get_node_type(size_node) != PLIST_UINT)
- return NULL;
- plist_get_uint_val(size_node, &size);
- plist_free(size_node);
- }
- return parse_dict_node(object, size, dict_size);
- default:
- return NULL;
- }
- return NULL;
+ uint16_t type = 0;
+ uint64_t size = 0;
+
+ if (!object)
+ return NULL;
+
+ type = (*object) & 0xF0;
+ size = (*object) & 0x0F;
+ object++;
+
+ switch (type)
+ {
+
+ case BPLIST_NULL:
+ switch (size)
+ {
+
+ case BPLIST_TRUE:
+ {
+ plist_data_t data = plist_new_plist_data();
+ data->type = PLIST_BOOLEAN;
+ data->boolval = TRUE;
+ data->length = 1;
+ return g_node_new(data);
+ }
+
+ case BPLIST_FALSE:
+ {
+ plist_data_t data = plist_new_plist_data();
+ data->type = PLIST_BOOLEAN;
+ data->boolval = FALSE;
+ data->length = 1;
+ return g_node_new(data);
+ }
+
+ case BPLIST_NULL:
+ default:
+ return NULL;
+ }
+
+ case BPLIST_UINT:
+ return parse_uint_node(object, size, next_object);
+
+ case BPLIST_REAL:
+ return parse_real_node(object, size);
+
+ case BPLIST_DATE:
+ if (3 != size)
+ return NULL;
+ else
+ return parse_date_node(object, size);
+
+ case BPLIST_DATA:
+ if (0x0F == size)
+ {
+ plist_t size_node = parse_bin_node(object, dict_size, &object);
+ if (plist_get_node_type(size_node) != PLIST_UINT)
+ return NULL;
+ plist_get_uint_val(size_node, &size);
+ plist_free(size_node);
+ }
+ return parse_data_node(object, size);
+
+ case BPLIST_STRING:
+ if (0x0F == size)
+ {
+ plist_t size_node = parse_bin_node(object, dict_size, &object);
+ if (plist_get_node_type(size_node) != PLIST_UINT)
+ return NULL;
+ plist_get_uint_val(size_node, &size);
+ plist_free(size_node);
+ }
+ return parse_string_node(object, size);
+
+ case BPLIST_UNICODE:
+ if (0x0F == size)
+ {
+ plist_t size_node = parse_bin_node(object, dict_size, &object);
+ if (plist_get_node_type(size_node) != PLIST_UINT)
+ return NULL;
+ plist_get_uint_val(size_node, &size);
+ plist_free(size_node);
+ }
+ return parse_unicode_node(object, size);
+
+ case BPLIST_UID:
+ case BPLIST_ARRAY:
+ if (0x0F == size)
+ {
+ plist_t size_node = parse_bin_node(object, dict_size, &object);
+ if (plist_get_node_type(size_node) != PLIST_UINT)
+ return NULL;
+ plist_get_uint_val(size_node, &size);
+ plist_free(size_node);
+ }
+ return parse_array_node(object, size, dict_size);
+
+ case BPLIST_SET:
+ case BPLIST_DICT:
+ if (0x0F == size)
+ {
+ plist_t size_node = parse_bin_node(object, dict_size, &object);
+ if (plist_get_node_type(size_node) != PLIST_UINT)
+ return NULL;
+ plist_get_uint_val(size_node, &size);
+ plist_free(size_node);
+ }
+ return parse_dict_node(object, size, dict_size);
+ default:
+ return NULL;
+ }
+ return NULL;
}
static gpointer copy_plist_data(gconstpointer src, gpointer data)
{
- plist_data_t srcdata = (plist_data_t) src;
- plist_data_t dstdata = plist_new_plist_data();
-
- dstdata->type = srcdata->type;
- dstdata->length = srcdata->length;
- switch (dstdata->type) {
- case PLIST_BOOLEAN:
- dstdata->boolval = srcdata->boolval;
- break;
- case PLIST_UINT:
- dstdata->intval = srcdata->intval;
- break;
- case PLIST_DATE:
- dstdata->timeval.tv_sec = srcdata->timeval.tv_sec;
- dstdata->timeval.tv_usec = srcdata->timeval.tv_usec;
- break;
- case PLIST_REAL:
- dstdata->realval = srcdata->realval;
- break;
- case PLIST_KEY:
- case PLIST_STRING:
- dstdata->strval = strdup(srcdata->strval);
- break;
- case PLIST_DATA:
- case PLIST_ARRAY:
- dstdata->buff = (uint8_t *) malloc(sizeof(uint8_t *) * srcdata->length);
- memcpy(dstdata->buff, srcdata->buff, sizeof(uint8_t *) * srcdata->length);
- break;
- case PLIST_DICT:
- dstdata->buff = (uint8_t *) malloc(sizeof(uint8_t *) * srcdata->length * 2);
- memcpy(dstdata->buff, srcdata->buff, sizeof(uint8_t *) * srcdata->length * 2);
- break;
- default:
- break;
- }
-
- return dstdata;
+ plist_data_t srcdata = (plist_data_t) src;
+ plist_data_t dstdata = plist_new_plist_data();
+
+ dstdata->type = srcdata->type;
+ dstdata->length = srcdata->length;
+ switch (dstdata->type)
+ {
+ case PLIST_BOOLEAN:
+ dstdata->boolval = srcdata->boolval;
+ break;
+ case PLIST_UINT:
+ dstdata->intval = srcdata->intval;
+ break;
+ case PLIST_DATE:
+ dstdata->timeval.tv_sec = srcdata->timeval.tv_sec;
+ dstdata->timeval.tv_usec = srcdata->timeval.tv_usec;
+ break;
+ case PLIST_REAL:
+ dstdata->realval = srcdata->realval;
+ break;
+ case PLIST_KEY:
+ case PLIST_STRING:
+ dstdata->strval = strdup(srcdata->strval);
+ break;
+ case PLIST_DATA:
+ case PLIST_ARRAY:
+ dstdata->buff = (uint8_t *) malloc(sizeof(uint8_t *) * srcdata->length);
+ memcpy(dstdata->buff, srcdata->buff, sizeof(uint8_t *) * srcdata->length);
+ break;
+ case PLIST_DICT:
+ dstdata->buff = (uint8_t *) malloc(sizeof(uint8_t *) * srcdata->length * 2);
+ memcpy(dstdata->buff, srcdata->buff, sizeof(uint8_t *) * srcdata->length * 2);
+ break;
+ default:
+ break;
+ }
+
+ return dstdata;
}
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);
+ 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);
}
static guint plist_data_hash(gconstpointer key)
{
- plist_data_t data = plist_get_data((plist_t) key);
-
- guint hash = data->type;
- guint i = 0;
-
- char *buff = NULL;
- guint size = 0;
-
- switch (data->type) {
- case PLIST_BOOLEAN:
- case PLIST_UINT:
- case PLIST_REAL:
- buff = (char *) &data->intval; //works also for real as we use an union
- size = 8;
- break;
- case PLIST_KEY:
- case PLIST_STRING:
- buff = data->strval;
- size = strlen(buff);
- break;
- case PLIST_DATA:
- case PLIST_ARRAY:
- case PLIST_DICT:
- //for these types only hash pointer
- buff = (char *) &key;
- size = sizeof(gconstpointer);
- break;
- case PLIST_DATE:
- buff = (char *) &(data->timeval);
- size = data->length;
- break;
- default:
- break;
- }
-
- //now perform hash
- for (i = 0; i < size; buff++, i++)
- hash = hash << 7 ^ (*buff);
-
- return hash;
+ plist_data_t data = plist_get_data((plist_t) key);
+
+ guint hash = data->type;
+ guint i = 0;
+
+ char *buff = NULL;
+ guint size = 0;
+
+ switch (data->type)
+ {
+ case PLIST_BOOLEAN:
+ case PLIST_UINT:
+ case PLIST_REAL:
+ buff = (char *) &data->intval; //works also for real as we use an union
+ size = 8;
+ break;
+ case PLIST_KEY:
+ case PLIST_STRING:
+ buff = data->strval;
+ size = strlen(buff);
+ break;
+ case PLIST_DATA:
+ case PLIST_ARRAY:
+ case PLIST_DICT:
+ //for these types only hash pointer
+ buff = (char *) &key;
+ size = sizeof(gconstpointer);
+ break;
+ case PLIST_DATE:
+ buff = (char *) &(data->timeval);
+ size = data->length;
+ break;
+ default:
+ break;
+ }
+
+ //now perform hash
+ for (i = 0; i < size; buff++, i++)
+ hash = hash << 7 ^ (*buff);
+
+ return hash;
}
-struct serialize_s {
- GPtrArray *objects;
- GHashTable *ref_table;
+struct serialize_s
+{
+ GPtrArray *objects;
+ GHashTable *ref_table;
};
static void serialize_plist(GNode * node, gpointer data)
{
- uint64_t *index_val = NULL;
- struct serialize_s *ser = (struct serialize_s *) data;
- uint64_t current_index = ser->objects->len;
-
- //first check that node is not yet in objects
- gpointer val = g_hash_table_lookup(ser->ref_table, node);
- if (val) {
- //data is already in table
- return;
- }
- //insert new ref
- index_val = (uint64_t *) malloc(sizeof(uint64_t));
- *index_val = current_index;
- g_hash_table_insert(ser->ref_table, node, index_val);
-
- //now append current node to object array
- g_ptr_array_add(ser->objects, node);
-
- //now recurse on children
- g_node_children_foreach(node, G_TRAVERSE_ALL, serialize_plist, data);
- return;
+ uint64_t *index_val = NULL;
+ struct serialize_s *ser = (struct serialize_s *) data;
+ uint64_t current_index = ser->objects->len;
+
+ //first check that node is not yet in objects
+ gpointer val = g_hash_table_lookup(ser->ref_table, node);
+ if (val)
+ {
+ //data is already in table
+ return;
+ }
+ //insert new ref
+ index_val = (uint64_t *) malloc(sizeof(uint64_t));
+ *index_val = current_index;
+ g_hash_table_insert(ser->ref_table, node, index_val);
+
+ //now append current node to object array
+ g_ptr_array_add(ser->objects, node);
+
+ //now recurse on children
+ g_node_children_foreach(node, G_TRAVERSE_ALL, serialize_plist, data);
+ return;
}
static gboolean free_index(gpointer key, gpointer value, gpointer user_data)
{
- free((uint64_t *) value);
- return TRUE;
+ free((uint64_t *) value);
+ return TRUE;
}
#define Log2(x) (x == 8 ? 3 : (x == 4 ? 2 : (x == 2 ? 1 : 0)))
static void write_int(GByteArray * bplist, uint64_t val)
{
- uint64_t size = get_needed_bytes(val);
- uint8_t *buff = NULL;
- //do not write 3bytes int node
- if (size == 3)
- size++;
- buff = (uint8_t *) malloc(sizeof(uint8_t) + size);
- buff[0] = BPLIST_UINT | Log2(size);
- memcpy(buff + 1, &val, size);
- byte_convert(buff + 1, size);
- g_byte_array_append(bplist, buff, sizeof(uint8_t) + size);
- free(buff);
+ uint64_t size = get_needed_bytes(val);
+ uint8_t *buff = NULL;
+ //do not write 3bytes int node
+ if (size == 3)
+ size++;
+ buff = (uint8_t *) malloc(sizeof(uint8_t) + size);
+ buff[0] = BPLIST_UINT | Log2(size);
+ memcpy(buff + 1, &val, size);
+ byte_convert(buff + 1, size);
+ g_byte_array_append(bplist, buff, sizeof(uint8_t) + size);
+ free(buff);
}
static void write_real(GByteArray * bplist, double val)
{
- uint64_t size = get_real_bytes(*((uint64_t *) & val)); //cheat to know used space
- uint8_t *buff = (uint8_t *) malloc(sizeof(uint8_t) + size);
- buff[0] = BPLIST_REAL | Log2(size);
- if (size == sizeof(double)) {
- memcpy(buff + 1, &val, size);
- } else if (size == sizeof(float)) {
- float tmpval = (float) val;
- memcpy(buff + 1, &tmpval, size);
- }
- byte_convert(buff + 1, size);
- g_byte_array_append(bplist, buff, sizeof(uint8_t) + size);
- free(buff);
+ uint64_t size = get_real_bytes(*((uint64_t *) & val)); //cheat to know used space
+ uint8_t *buff = (uint8_t *) malloc(sizeof(uint8_t) + size);
+ buff[0] = BPLIST_REAL | Log2(size);
+ if (size == sizeof(double))
+ {
+ memcpy(buff + 1, &val, size);
+ }
+ else if (size == sizeof(float))
+ {
+ float tmpval = (float) val;
+ memcpy(buff + 1, &tmpval, size);
+ }
+ byte_convert(buff + 1, size);
+ g_byte_array_append(bplist, buff, sizeof(uint8_t) + size);
+ free(buff);
}
static void write_date(GByteArray * bplist, double val)
{
- uint64_t size = 8; //dates always use 8 bytes
- uint8_t *buff = (uint8_t *) malloc(sizeof(uint8_t) + size);
- buff[0] = BPLIST_DATE | Log2(size);
- memcpy(buff + 1, &val, size);
- byte_convert(buff + 1, size);
- g_byte_array_append(bplist, buff, sizeof(uint8_t) + size);
- free(buff);
+ uint64_t size = 8; //dates always use 8 bytes
+ uint8_t *buff = (uint8_t *) malloc(sizeof(uint8_t) + size);
+ buff[0] = BPLIST_DATE | Log2(size);
+ memcpy(buff + 1, &val, size);
+ byte_convert(buff + 1, size);
+ g_byte_array_append(bplist, buff, sizeof(uint8_t) + size);
+ free(buff);
}
static void write_raw_data(GByteArray * bplist, uint8_t mark, uint8_t * val, uint64_t size)
{
- uint8_t *buff = NULL;
- uint8_t marker = mark | (size < 15 ? size : 0xf);
- g_byte_array_append(bplist, &marker, sizeof(uint8_t));
- if (size >= 15) {
- GByteArray *int_buff = g_byte_array_new();
- write_int(int_buff, size);
- g_byte_array_append(bplist, int_buff->data, int_buff->len);
- g_byte_array_free(int_buff, TRUE);
- }
- buff = (uint8_t *) malloc(size);
- memcpy(buff, val, size);
- g_byte_array_append(bplist, buff, size);
- free(buff);
+ uint8_t *buff = NULL;
+ uint8_t marker = mark | (size < 15 ? size : 0xf);
+ g_byte_array_append(bplist, &marker, sizeof(uint8_t));
+ if (size >= 15)
+ {
+ GByteArray *int_buff = g_byte_array_new();
+ write_int(int_buff, size);
+ g_byte_array_append(bplist, int_buff->data, int_buff->len);
+ g_byte_array_free(int_buff, TRUE);
+ }
+ buff = (uint8_t *) malloc(size);
+ memcpy(buff, val, size);
+ g_byte_array_append(bplist, buff, size);
+ free(buff);
}
static void write_data(GByteArray * bplist, uint8_t * val, uint64_t size)
{
- write_raw_data(bplist, BPLIST_DATA, val, size);
+ write_raw_data(bplist, BPLIST_DATA, val, size);
}
static void write_string(GByteArray * bplist, char *val)
{
- uint64_t size = strlen(val);
- write_raw_data(bplist, BPLIST_STRING, (uint8_t *) val, size);
+ uint64_t size = strlen(val);
+ write_raw_data(bplist, BPLIST_STRING, (uint8_t *) val, size);
}
static void write_unicode(GByteArray * bplist, gunichar2 * val, uint64_t size)
{
- uint64_t i = 0;
- uint64_t size2 = size * sizeof(gunichar2);
- uint8_t *buff = (uint8_t *) malloc(size2);
- memcpy(buff, val, size2);
- for (i = 0; i < size; i++)
- byte_convert(buff + i * sizeof(gunichar2), sizeof(gunichar2));
- write_raw_data(bplist, BPLIST_STRING, buff, size2);
+ uint64_t i = 0;
+ uint64_t size2 = size * sizeof(gunichar2);
+ uint8_t *buff = (uint8_t *) malloc(size2);
+ memcpy(buff, val, size2);
+ for (i = 0; i < size; i++)
+ byte_convert(buff + i * sizeof(gunichar2), sizeof(gunichar2));
+ write_raw_data(bplist, BPLIST_STRING, buff, size2);
}
static void write_array(GByteArray * bplist, GNode * node, GHashTable * ref_table, uint8_t dict_param_size)
{
- uint64_t idx = 0;
- uint8_t *buff = NULL;
-
- GNode *cur = NULL;
- uint64_t i = 0;
-
- uint64_t size = g_node_n_children(node);
- uint8_t marker = BPLIST_ARRAY | (size < 15 ? size : 0xf);
- g_byte_array_append(bplist, &marker, sizeof(uint8_t));
- if (size >= 15) {
- GByteArray *int_buff = g_byte_array_new();
- write_int(int_buff, size);
- g_byte_array_append(bplist, int_buff->data, int_buff->len);
- g_byte_array_free(int_buff, TRUE);
- }
-
- buff = (uint8_t *) malloc(size * dict_param_size);
-
- for (i = 0, cur = node->children; cur && i < size; cur = cur->next, i++) {
- idx = *(uint64_t *) (g_hash_table_lookup(ref_table, cur));
- memcpy(buff + i * dict_param_size, &idx, dict_param_size);
- byte_convert(buff + i * dict_param_size, dict_param_size);
- }
-
- //now append to bplist
- g_byte_array_append(bplist, buff, size * dict_param_size);
- free(buff);
+ uint64_t idx = 0;
+ uint8_t *buff = NULL;
+
+ GNode *cur = NULL;
+ uint64_t i = 0;
+
+ uint64_t size = g_node_n_children(node);
+ uint8_t marker = BPLIST_ARRAY | (size < 15 ? size : 0xf);
+ g_byte_array_append(bplist, &marker, sizeof(uint8_t));
+ if (size >= 15)
+ {
+ GByteArray *int_buff = g_byte_array_new();
+ write_int(int_buff, size);
+ g_byte_array_append(bplist, int_buff->data, int_buff->len);
+ g_byte_array_free(int_buff, TRUE);
+ }
+
+ buff = (uint8_t *) malloc(size * dict_param_size);
+
+ for (i = 0, cur = node->children; cur && i < size; cur = cur->next, i++)
+ {
+ idx = *(uint64_t *) (g_hash_table_lookup(ref_table, cur));
+ memcpy(buff + i * dict_param_size, &idx, dict_param_size);
+ byte_convert(buff + i * dict_param_size, dict_param_size);
+ }
+
+ //now append to bplist
+ g_byte_array_append(bplist, buff, size * dict_param_size);
+ free(buff);
}
static void write_dict(GByteArray * bplist, GNode * node, GHashTable * ref_table, uint8_t dict_param_size)
{
- uint64_t idx1 = 0;
- uint64_t idx2 = 0;
- uint8_t *buff = NULL;
-
- GNode *cur = NULL;
- uint64_t i = 0;
-
- uint64_t size = g_node_n_children(node) / 2;
- uint8_t marker = BPLIST_DICT | (size < 15 ? size : 0xf);
- g_byte_array_append(bplist, &marker, sizeof(uint8_t));
- if (size >= 15) {
- GByteArray *int_buff = g_byte_array_new();
- write_int(int_buff, size);
- g_byte_array_append(bplist, int_buff->data, int_buff->len);
- g_byte_array_free(int_buff, TRUE);
- }
-
- buff = (uint8_t *) malloc(size * 2 * dict_param_size);
-
- for (i = 0, cur = node->children; cur && i < size; cur = cur->next->next, i++) {
- idx1 = *(uint64_t *) (g_hash_table_lookup(ref_table, cur));
- memcpy(buff + i * dict_param_size, &idx1, dict_param_size);
- byte_convert(buff + i * dict_param_size, dict_param_size);
-
- idx2 = *(uint64_t *) (g_hash_table_lookup(ref_table, cur->next));
- memcpy(buff + (i + size) * dict_param_size, &idx2, dict_param_size);
- byte_convert(buff + (i + size) * dict_param_size, dict_param_size);
- }
-
- //now append to bplist
- g_byte_array_append(bplist, buff, size * 2 * dict_param_size);
- free(buff);
+ uint64_t idx1 = 0;
+ uint64_t idx2 = 0;
+ uint8_t *buff = NULL;
+
+ GNode *cur = NULL;
+ uint64_t i = 0;
+
+ uint64_t size = g_node_n_children(node) / 2;
+ uint8_t marker = BPLIST_DICT | (size < 15 ? size : 0xf);
+ g_byte_array_append(bplist, &marker, sizeof(uint8_t));
+ if (size >= 15)
+ {
+ GByteArray *int_buff = g_byte_array_new();
+ write_int(int_buff, size);
+ g_byte_array_append(bplist, int_buff->data, int_buff->len);
+ g_byte_array_free(int_buff, TRUE);
+ }
+
+ buff = (uint8_t *) malloc(size * 2 * dict_param_size);
+
+ for (i = 0, cur = node->children; cur && i < size; cur = cur->next->next, i++)
+ {
+ idx1 = *(uint64_t *) (g_hash_table_lookup(ref_table, cur));
+ memcpy(buff + i * dict_param_size, &idx1, dict_param_size);
+ byte_convert(buff + i * dict_param_size, dict_param_size);
+
+ idx2 = *(uint64_t *) (g_hash_table_lookup(ref_table, cur->next));
+ memcpy(buff + (i + size) * dict_param_size, &idx2, dict_param_size);
+ byte_convert(buff + (i + size) * dict_param_size, dict_param_size);
+ }
+
+ //now append to bplist
+ g_byte_array_append(bplist, buff, size * 2 * dict_param_size);
+ free(buff);
}
void plist_to_bin(plist_t plist, char **plist_bin, uint32_t * length)
{
- GPtrArray *objects = NULL;
- GHashTable *ref_table = NULL;
- struct serialize_s ser_s;
- 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;
- GByteArray *bplist_buff = NULL;
- uint64_t i = 0;
- uint8_t *buff = NULL;
- uint64_t *offsets = NULL;
- uint8_t pad[6] = { 0, 0, 0, 0, 0, 0 };
- uint8_t trailer[BPLIST_TRL_SIZE];
- //for string
- glong len = 0;
- int type = 0;
- glong items_read = 0;
- glong items_written = 0;
- GError *error = NULL;
- gunichar2 *unicodestr = NULL;
-
- //check for valid input
- if (!plist || !plist_bin || *plist_bin || !length)
- return;
-
- //list of objects
- objects = g_ptr_array_new();
- //hashtable to write only once same nodes
- ref_table = g_hash_table_new(plist_data_hash, plist_data_compare);
-
- //serialize plist
- ser_s.objects = objects;
- ser_s.ref_table = ref_table;
- serialize_plist(plist, &ser_s);
-
- //now stream to output buffer
- offset_size = 0; //unknown yet
- dict_param_size = get_needed_bytes(objects->len);
- num_objects = objects->len;
- root_object = 0; //root is first in list
- offset_table_index = 0; //unknown yet
-
- //setup a dynamic bytes array to store bplist in
- bplist_buff = g_byte_array_new();
-
- //set magic number and version
- g_byte_array_append(bplist_buff, BPLIST_MAGIC, BPLIST_MAGIC_SIZE);
- g_byte_array_append(bplist_buff, BPLIST_VERSION, BPLIST_VERSION_SIZE);
-
- //write objects and table
- offsets = (uint64_t *) malloc(num_objects * sizeof(uint64_t));
- for (i = 0; i < num_objects; i++) {
-
- plist_data_t data = plist_get_data(g_ptr_array_index(objects, i));
- offsets[i] = bplist_buff->len;
-
- switch (data->type) {
- case PLIST_BOOLEAN:
- buff = (uint8_t *) malloc(sizeof(uint8_t));
- buff[0] = data->boolval ? BPLIST_TRUE : BPLIST_FALSE;
- g_byte_array_append(bplist_buff, buff, sizeof(uint8_t));
- free(buff);
- break;
-
- case PLIST_UINT:
- write_int(bplist_buff, data->intval);
- break;
-
- case PLIST_REAL:
- write_real(bplist_buff, data->realval);
- break;
-
- case PLIST_KEY:
- case PLIST_STRING:
- len = strlen(data->strval);
- type = xmlDetectCharEncoding(data->strval, len);
- if (XML_CHAR_ENCODING_UTF8 == type) {
- unicodestr = g_utf8_to_utf16(data->strval, len, &items_read, &items_written, &error);
- write_unicode(bplist_buff, unicodestr, items_written);
- g_free(unicodestr);
- } else if (XML_CHAR_ENCODING_ASCII == type || XML_CHAR_ENCODING_NONE == type) {
- write_string(bplist_buff, data->strval);
- }
- break;
- case PLIST_DATA:
- write_data(bplist_buff, data->buff, data->length);
- case PLIST_ARRAY:
- write_array(bplist_buff, g_ptr_array_index(objects, i), ref_table, dict_param_size);
- break;
- case PLIST_DICT:
- write_dict(bplist_buff, g_ptr_array_index(objects, i), ref_table, dict_param_size);
- break;
- case PLIST_DATE:
- write_date(bplist_buff, data->timeval.tv_sec + (double) data->timeval.tv_usec / G_USEC_PER_SEC);
- break;
- default:
- break;
- }
- }
-
- //free intermediate objects
- g_hash_table_foreach_remove(ref_table, free_index, NULL);
- g_ptr_array_free(objects, TRUE);
- g_hash_table_destroy(ref_table);
-
- //write offsets
- offset_size = get_needed_bytes(bplist_buff->len);
- offset_table_index = bplist_buff->len;
- for (i = 0; i < num_objects; i++) {
- uint8_t *offsetbuff = (uint8_t *) malloc(offset_size);
- memcpy(offsetbuff, offsets + i, offset_size);
- byte_convert(offsetbuff, offset_size);
- g_byte_array_append(bplist_buff, offsetbuff, offset_size);
- free(offsetbuff);
- }
-
- //experimental pad to reflect apple's files
- g_byte_array_append(bplist_buff, pad, 6);
-
- //setup trailer
- num_objects = GUINT64_FROM_BE(num_objects);
- root_object = GUINT64_FROM_BE(root_object);
- offset_table_index = GUINT64_FROM_BE(offset_table_index);
-
- memcpy(trailer + BPLIST_TRL_OFFSIZE_IDX, &offset_size, sizeof(uint8_t));
- memcpy(trailer + BPLIST_TRL_PARMSIZE_IDX, &dict_param_size, sizeof(uint8_t));
- memcpy(trailer + BPLIST_TRL_NUMOBJ_IDX, &num_objects, sizeof(uint64_t));
- memcpy(trailer + BPLIST_TRL_ROOTOBJ_IDX, &root_object, sizeof(uint64_t));
- memcpy(trailer + BPLIST_TRL_OFFTAB_IDX, &offset_table_index, sizeof(uint64_t));
-
- g_byte_array_append(bplist_buff, trailer, BPLIST_TRL_SIZE);
-
- //duplicate buffer
- *plist_bin = (char *) malloc(bplist_buff->len);
- memcpy(*plist_bin, bplist_buff->data, bplist_buff->len);
- *length = bplist_buff->len;
-
- g_byte_array_free(bplist_buff, TRUE);
- free(offsets);
+ GPtrArray *objects = NULL;
+ GHashTable *ref_table = NULL;
+ struct serialize_s ser_s;
+ 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;
+ GByteArray *bplist_buff = NULL;
+ uint64_t i = 0;
+ uint8_t *buff = NULL;
+ uint64_t *offsets = NULL;
+ uint8_t pad[6] = { 0, 0, 0, 0, 0, 0 };
+ uint8_t trailer[BPLIST_TRL_SIZE];
+ //for string
+ glong len = 0;
+ int type = 0;
+ glong items_read = 0;
+ glong items_written = 0;
+ GError *error = NULL;
+ gunichar2 *unicodestr = NULL;
+
+ //check for valid input
+ if (!plist || !plist_bin || *plist_bin || !length)
+ return;
+
+ //list of objects
+ objects = g_ptr_array_new();
+ //hashtable to write only once same nodes
+ ref_table = g_hash_table_new(plist_data_hash, plist_data_compare);
+
+ //serialize plist
+ ser_s.objects = objects;
+ ser_s.ref_table = ref_table;
+ serialize_plist(plist, &ser_s);
+
+ //now stream to output buffer
+ offset_size = 0; //unknown yet
+ dict_param_size = get_needed_bytes(objects->len);
+ num_objects = objects->len;
+ root_object = 0; //root is first in list
+ offset_table_index = 0; //unknown yet
+
+ //setup a dynamic bytes array to store bplist in
+ bplist_buff = g_byte_array_new();
+
+ //set magic number and version
+ g_byte_array_append(bplist_buff, BPLIST_MAGIC, BPLIST_MAGIC_SIZE);
+ g_byte_array_append(bplist_buff, BPLIST_VERSION, BPLIST_VERSION_SIZE);
+
+ //write objects and table
+ offsets = (uint64_t *) malloc(num_objects * sizeof(uint64_t));
+ for (i = 0; i < num_objects; i++)
+ {
+
+ plist_data_t data = plist_get_data(g_ptr_array_index(objects, i));
+ offsets[i] = bplist_buff->len;
+
+ switch (data->type)
+ {
+ case PLIST_BOOLEAN:
+ buff = (uint8_t *) malloc(sizeof(uint8_t));
+ buff[0] = data->boolval ? BPLIST_TRUE : BPLIST_FALSE;
+ g_byte_array_append(bplist_buff, buff, sizeof(uint8_t));
+ free(buff);
+ break;
+
+ case PLIST_UINT:
+ write_int(bplist_buff, data->intval);
+ break;
+
+ case PLIST_REAL:
+ write_real(bplist_buff, data->realval);
+ break;
+
+ case PLIST_KEY:
+ case PLIST_STRING:
+ len = strlen(data->strval);
+ type = xmlDetectCharEncoding(data->strval, len);
+ if (XML_CHAR_ENCODING_UTF8 == type)
+ {
+ unicodestr = g_utf8_to_utf16(data->strval, len, &items_read, &items_written, &error);
+ write_unicode(bplist_buff, unicodestr, items_written);
+ g_free(unicodestr);
+ }
+ else if (XML_CHAR_ENCODING_ASCII == type || XML_CHAR_ENCODING_NONE == type)
+ {
+ write_string(bplist_buff, data->strval);
+ }
+ break;
+ case PLIST_DATA:
+ write_data(bplist_buff, data->buff, data->length);
+ case PLIST_ARRAY:
+ write_array(bplist_buff, g_ptr_array_index(objects, i), ref_table, dict_param_size);
+ break;
+ case PLIST_DICT:
+ write_dict(bplist_buff, g_ptr_array_index(objects, i), ref_table, dict_param_size);
+ break;
+ case PLIST_DATE:
+ write_date(bplist_buff, data->timeval.tv_sec + (double) data->timeval.tv_usec / G_USEC_PER_SEC);
+ break;
+ default:
+ break;
+ }
+ }
+
+ //free intermediate objects
+ g_hash_table_foreach_remove(ref_table, free_index, NULL);
+ g_ptr_array_free(objects, TRUE);
+ g_hash_table_destroy(ref_table);
+
+ //write offsets
+ offset_size = get_needed_bytes(bplist_buff->len);
+ offset_table_index = bplist_buff->len;
+ for (i = 0; i < num_objects; i++)
+ {
+ uint8_t *offsetbuff = (uint8_t *) malloc(offset_size);
+ memcpy(offsetbuff, offsets + i, offset_size);
+ byte_convert(offsetbuff, offset_size);
+ g_byte_array_append(bplist_buff, offsetbuff, offset_size);
+ free(offsetbuff);
+ }
+
+ //experimental pad to reflect apple's files
+ g_byte_array_append(bplist_buff, pad, 6);
+
+ //setup trailer
+ num_objects = GUINT64_FROM_BE(num_objects);
+ root_object = GUINT64_FROM_BE(root_object);
+ offset_table_index = GUINT64_FROM_BE(offset_table_index);
+
+ memcpy(trailer + BPLIST_TRL_OFFSIZE_IDX, &offset_size, sizeof(uint8_t));
+ memcpy(trailer + BPLIST_TRL_PARMSIZE_IDX, &dict_param_size, sizeof(uint8_t));
+ memcpy(trailer + BPLIST_TRL_NUMOBJ_IDX, &num_objects, sizeof(uint64_t));
+ memcpy(trailer + BPLIST_TRL_ROOTOBJ_IDX, &root_object, sizeof(uint64_t));
+ memcpy(trailer + BPLIST_TRL_OFFTAB_IDX, &offset_table_index, sizeof(uint64_t));
+
+ g_byte_array_append(bplist_buff, trailer, BPLIST_TRL_SIZE);
+
+ //duplicate buffer
+ *plist_bin = (char *) malloc(bplist_buff->len);
+ memcpy(*plist_bin, bplist_buff->data, bplist_buff->len);
+ *length = bplist_buff->len;
+
+ g_byte_array_free(bplist_buff, TRUE);
+ free(offsets);
}
diff --git a/src/plist.c b/src/plist.c
index 30be007..9628e38 100644
--- a/src/plist.c
+++ b/src/plist.c
@@ -28,719 +28,762 @@
plist_t plist_new_node(plist_data_t data)
{
- return (plist_t) g_node_new(data);
+ return (plist_t) g_node_new(data);
}
plist_data_t plist_get_data(const plist_t node)
{
- if (!node)
- return NULL;
- return ((GNode *) node)->data;
+ if (!node)
+ return NULL;
+ return ((GNode *) node)->data;
}
plist_data_t plist_new_plist_data(void)
{
- plist_data_t data = (plist_data_t) calloc(sizeof(struct plist_data_s), 1);
- return data;
+ plist_data_t data = (plist_data_t) calloc(sizeof(struct plist_data_s), 1);
+ return data;
}
static void plist_free_data(plist_data_t data)
{
- if (data) {
- switch (data->type) {
- case PLIST_KEY:
- case PLIST_STRING:
- free(data->strval);
- break;
- case PLIST_DATA:
- free(data->buff);
- break;
- default:
- break;
- }
- free(data);
- }
+ if (data)
+ {
+ switch (data->type)
+ {
+ case PLIST_KEY:
+ case PLIST_STRING:
+ free(data->strval);
+ break;
+ case PLIST_DATA:
+ free(data->buff);
+ break;
+ default:
+ break;
+ }
+ free(data);
+ }
}
static void plist_free_node(GNode * node, gpointer none)
{
plist_data_t data = NULL;
- g_node_unlink(node);
- data = plist_get_data(node);
- plist_free_data(data);
- node->data = NULL;
- g_node_children_foreach(node, G_TRAVERSE_ALL, plist_free_node, NULL);
+ g_node_unlink(node);
+ data = plist_get_data(node);
+ plist_free_data(data);
+ node->data = NULL;
+ g_node_children_foreach(node, G_TRAVERSE_ALL, plist_free_node, NULL);
}
plist_t plist_new_dict(void)
{
- plist_data_t data = plist_new_plist_data();
- data->type = PLIST_DICT;
- return plist_new_node(data);
+ plist_data_t data = plist_new_plist_data();
+ data->type = PLIST_DICT;
+ return plist_new_node(data);
}
plist_t plist_new_array(void)
{
- plist_data_t data = plist_new_plist_data();
- data->type = PLIST_ARRAY;
- return plist_new_node(data);
+ plist_data_t data = plist_new_plist_data();
+ data->type = PLIST_ARRAY;
+ return plist_new_node(data);
}
//These nodes should not be handled by users
static plist_t plist_new_key(const char *val)
{
- plist_data_t data = plist_new_plist_data();
- data->type = PLIST_KEY;
- data->strval = strdup(val);
- data->length = strlen(val);
- return plist_new_node(data);
+ plist_data_t data = plist_new_plist_data();
+ data->type = PLIST_KEY;
+ data->strval = strdup(val);
+ data->length = strlen(val);
+ return plist_new_node(data);
}
plist_t plist_new_string(const char *val)
{
- plist_data_t data = plist_new_plist_data();
- data->type = PLIST_STRING;
- data->strval = strdup(val);
- data->length = strlen(val);
- return plist_new_node(data);
+ plist_data_t data = plist_new_plist_data();
+ data->type = PLIST_STRING;
+ data->strval = strdup(val);
+ data->length = strlen(val);
+ return plist_new_node(data);
}
plist_t plist_new_bool(uint8_t val)
{
- plist_data_t data = plist_new_plist_data();
- data->type = PLIST_BOOLEAN;
- data->boolval = val;
- data->length = sizeof(uint8_t);
- return plist_new_node(data);
+ plist_data_t data = plist_new_plist_data();
+ data->type = PLIST_BOOLEAN;
+ data->boolval = val;
+ data->length = sizeof(uint8_t);
+ return plist_new_node(data);
}
plist_t plist_new_uint(uint64_t val)
{
- plist_data_t data = plist_new_plist_data();
- data->type = PLIST_UINT;
- data->intval = val;
- data->length = sizeof(uint64_t);
- return plist_new_node(data);
+ plist_data_t data = plist_new_plist_data();
+ data->type = PLIST_UINT;
+ data->intval = val;
+ data->length = sizeof(uint64_t);
+ return plist_new_node(data);
}
plist_t plist_new_real(double val)
{
- plist_data_t data = plist_new_plist_data();
- data->type = PLIST_REAL;
- data->realval = val;
- data->length = sizeof(double);
- return plist_new_node(data);
+ plist_data_t data = plist_new_plist_data();
+ data->type = PLIST_REAL;
+ data->realval = val;
+ data->length = sizeof(double);
+ return plist_new_node(data);
}
plist_t plist_new_data(const char *val, uint64_t length)
{
- plist_data_t data = plist_new_plist_data();
- data->type = PLIST_DATA;
- data->buff = (uint8_t *) malloc(length);
- memcpy(data->buff, val, length);
- data->length = length;
- return plist_new_node(data);
+ plist_data_t data = plist_new_plist_data();
+ data->type = PLIST_DATA;
+ data->buff = (uint8_t *) malloc(length);
+ memcpy(data->buff, val, length);
+ data->length = length;
+ return plist_new_node(data);
}
plist_t plist_new_date(int32_t sec, int32_t usec)
{
- plist_data_t data = plist_new_plist_data();
- data->type = PLIST_DATE;
- data->timeval.tv_sec = sec;
- data->timeval.tv_usec = usec;
- data->length = sizeof(GTimeVal);
- return plist_new_node(data);
+ plist_data_t data = plist_new_plist_data();
+ data->type = PLIST_DATE;
+ data->timeval.tv_sec = sec;
+ data->timeval.tv_usec = usec;
+ data->length = sizeof(GTimeVal);
+ return plist_new_node(data);
}
void plist_free(plist_t plist)
{
- if (plist) {
- plist_free_node(plist, NULL);
- g_node_destroy(plist);
- }
+ if (plist)
+ {
+ plist_free_node(plist, NULL);
+ g_node_destroy(plist);
+ }
}
static void plist_copy_node(GNode * node, gpointer parent_node_ptr)
{
plist_type node_type = PLIST_NONE;
- plist_t newnode = NULL;
- plist_data_t data = plist_get_data(node);
- plist_data_t newdata = plist_new_plist_data();
-
- assert(data); // plist should always have data
-
- memcpy(newdata, data, sizeof(struct plist_data_s));
-
- node_type = plist_get_node_type(node);
- if (node_type == PLIST_DATA || node_type == PLIST_STRING || node_type == PLIST_KEY) {
- switch (node_type) {
- case PLIST_DATA:
- newdata->buff = (uint8_t *) malloc(data->length);
- memcpy(newdata->buff, data->buff, data->length);
- case PLIST_KEY:
- case PLIST_STRING:
- newdata->strval = strdup((char *) data->strval);
- default:
- break;
- }
- }
- newnode = plist_new_node(newdata);
-
- if (*(plist_t*)parent_node_ptr) {
- g_node_append(*(plist_t*)parent_node_ptr, newnode);
- }
- else {
- *(plist_t*)parent_node_ptr = newnode;
- }
-
- g_node_children_foreach(node, G_TRAVERSE_ALL, plist_copy_node, &newnode);
+ plist_t newnode = NULL;
+ plist_data_t data = plist_get_data(node);
+ plist_data_t newdata = plist_new_plist_data();
+
+ assert(data); // plist should always have data
+
+ memcpy(newdata, data, sizeof(struct plist_data_s));
+
+ node_type = plist_get_node_type(node);
+ if (node_type == PLIST_DATA || node_type == PLIST_STRING || node_type == PLIST_KEY)
+ {
+ switch (node_type)
+ {
+ case PLIST_DATA:
+ newdata->buff = (uint8_t *) malloc(data->length);
+ memcpy(newdata->buff, data->buff, data->length);
+ case PLIST_KEY:
+ case PLIST_STRING:
+ newdata->strval = strdup((char *) data->strval);
+ default:
+ break;
+ }
+ }
+ newnode = plist_new_node(newdata);
+
+ if (*(plist_t*)parent_node_ptr)
+ {
+ g_node_append(*(plist_t*)parent_node_ptr, newnode);
+ }
+ else
+ {
+ *(plist_t*)parent_node_ptr = newnode;
+ }
+
+ g_node_children_foreach(node, G_TRAVERSE_ALL, plist_copy_node, &newnode);
}
plist_t plist_copy(plist_t node)
{
- plist_t copied = NULL;
- plist_copy_node(node, &copied);
- return copied;
+ plist_t copied = NULL;
+ plist_copy_node(node, &copied);
+ return copied;
}
uint32_t plist_array_get_size(plist_t node)
{
- uint32_t ret = 0;
- if (node && PLIST_ARRAY == plist_get_node_type(node)) {
- ret = g_node_n_children(node);
- }
- return ret;
+ uint32_t ret = 0;
+ if (node && PLIST_ARRAY == plist_get_node_type(node))
+ {
+ ret = g_node_n_children(node);
+ }
+ return ret;
}
plist_t plist_array_get_item(plist_t node, uint32_t n)
{
- plist_t ret = NULL;
- if (node && PLIST_ARRAY == plist_get_node_type(node)) {
- ret = (plist_t)g_node_nth_child(node, n);
- }
- return ret;
+ plist_t ret = NULL;
+ if (node && PLIST_ARRAY == plist_get_node_type(node))
+ {
+ ret = (plist_t)g_node_nth_child(node, n);
+ }
+ return ret;
}
uint32_t plist_array_get_item_index(plist_t node)
{
- plist_t father = plist_get_parent(node);
- if (PLIST_ARRAY == plist_get_node_type(father)) {
- return g_node_child_position(father, node);
- }
+ plist_t father = plist_get_parent(node);
+ if (PLIST_ARRAY == plist_get_node_type(father))
+ {
+ return g_node_child_position(father, node);
+ }
return 0;
}
void plist_array_set_item(plist_t node, plist_t item, uint32_t n)
{
- if (node && PLIST_ARRAY == plist_get_node_type(node)) {
- plist_t old_item = plist_array_get_item(node, n);
- if (old_item) {
- plist_free_node(old_item, NULL);
- old_item = NULL;
- plist_copy_node(item, &old_item);
- }
- }
- return;
+ if (node && PLIST_ARRAY == plist_get_node_type(node))
+ {
+ plist_t old_item = plist_array_get_item(node, n);
+ if (old_item)
+ {
+ plist_free_node(old_item, NULL);
+ old_item = NULL;
+ plist_copy_node(item, &old_item);
+ }
+ }
+ return;
}
void plist_array_append_item(plist_t node, plist_t item)
{
- if (node && PLIST_ARRAY == plist_get_node_type(node)) {
- g_node_append(node, item);
- }
- return;
+ if (node && PLIST_ARRAY == plist_get_node_type(node))
+ {
+ g_node_append(node, item);
+ }
+ return;
}
void plist_array_insert_item(plist_t node, plist_t item, uint32_t n)
{
- if (node && PLIST_ARRAY == plist_get_node_type(node)) {
- g_node_insert(node, n, item);
- }
- return;
+ if (node && PLIST_ARRAY == plist_get_node_type(node))
+ {
+ g_node_insert(node, n, item);
+ }
+ return;
}
void plist_array_remove_item(plist_t node, uint32_t n)
{
- if (node && PLIST_ARRAY == plist_get_node_type(node)) {
- plist_t old_item = plist_array_get_item(node, n);
- if (old_item) {
- plist_free(old_item);
- }
- }
- return;
+ if (node && PLIST_ARRAY == plist_get_node_type(node))
+ {
+ plist_t old_item = plist_array_get_item(node, n);
+ if (old_item)
+ {
+ plist_free(old_item);
+ }
+ }
+ return;
}
uint32_t plist_dict_get_size(plist_t node)
{
- uint32_t ret = 0;
- if (node && PLIST_DICT == plist_get_node_type(node)) {
- ret = g_node_n_children(node) / 2;
- }
- return ret;
+ uint32_t ret = 0;
+ if (node && PLIST_DICT == plist_get_node_type(node))
+ {
+ ret = g_node_n_children(node) / 2;
+ }
+ return ret;
}
void plist_dict_new_iter(plist_t node, plist_dict_iter *iter)
{
- if (iter && *iter == NULL) {
- *iter = malloc(sizeof(uint32_t));
- *((uint32_t*)(*iter)) = 0;
- }
- return;
+ if (iter && *iter == NULL)
+ {
+ *iter = malloc(sizeof(uint32_t));
+ *((uint32_t*)(*iter)) = 0;
+ }
+ return;
}
void plist_dict_next_item(plist_t node, plist_dict_iter iter, char **key, plist_t *val)
{
- uint32_t* iter_int = (uint32_t*) iter;
+ uint32_t* iter_int = (uint32_t*) iter;
- if (key) {
- *key = NULL;
- }
- if (val) {
- *val = NULL;
- }
+ if (key)
+ {
+ *key = NULL;
+ }
+ if (val)
+ {
+ *val = NULL;
+ }
- if (node && PLIST_DICT == plist_get_node_type(node) && *iter_int < g_node_n_children(node)) {
+ if (node && PLIST_DICT == plist_get_node_type(node) && *iter_int < g_node_n_children(node))
+ {
- if (key) {
- plist_get_key_val((plist_t)g_node_nth_child(node, *iter_int), key);
- }
+ if (key)
+ {
+ plist_get_key_val((plist_t)g_node_nth_child(node, *iter_int), key);
+ }
- if (val) {
- *val = (plist_t) g_node_nth_child(node, *iter_int + 1);
- }
+ if (val)
+ {
+ *val = (plist_t) g_node_nth_child(node, *iter_int + 1);
+ }
- *iter_int += 2;
- }
- return;
+ *iter_int += 2;
+ }
+ return;
}
void plist_dict_get_item_key(plist_t node, char **key)
{
- plist_t father = plist_get_parent(node);
- if (PLIST_DICT == plist_get_node_type(father)) {
- plist_get_key_val( (plist_t) g_node_prev_sibling(node), key);
- }
+ plist_t father = plist_get_parent(node);
+ if (PLIST_DICT == plist_get_node_type(father))
+ {
+ plist_get_key_val( (plist_t) g_node_prev_sibling(node), key);
+ }
}
plist_t plist_dict_get_item(plist_t node, const char* key)
{
- plist_t ret = NULL;
+ plist_t ret = NULL;
- if (node && PLIST_DICT == plist_get_node_type(node)) {
+ if (node && PLIST_DICT == plist_get_node_type(node))
+ {
- plist_t current = NULL;
- for (current = (plist_t)g_node_first_child(node);
- current;
- current = (plist_t)g_node_next_sibling(g_node_next_sibling(current))) {
+ plist_t current = NULL;
+ for (current = (plist_t)g_node_first_child(node);
+ current;
+ current = (plist_t)g_node_next_sibling(g_node_next_sibling(current)))
+ {
- plist_data_t data = plist_get_data(current);
+ plist_data_t data = plist_get_data(current);
assert( PLIST_KEY == plist_get_node_type(current) );
- if (data && !strcmp(key, data->strval)) {
- ret = (plist_t)g_node_next_sibling(current);
- break;
- }
- }
- }
- return ret;
+ if (data && !strcmp(key, data->strval))
+ {
+ ret = (plist_t)g_node_next_sibling(current);
+ break;
+ }
+ }
+ }
+ return ret;
}
void plist_dict_set_item(plist_t node, const char* key, plist_t item)
{
- if (node && PLIST_DICT == plist_get_node_type(node)) {
- plist_t old_item = plist_dict_get_item(node, key);
- if (old_item) {
- plist_free_node(old_item, NULL);
- old_item = NULL;
- plist_copy_node(item, &old_item);
- }
- }
- return;
+ if (node && PLIST_DICT == plist_get_node_type(node))
+ {
+ plist_t old_item = plist_dict_get_item(node, key);
+ if (old_item)
+ {
+ plist_free_node(old_item, NULL);
+ old_item = NULL;
+ plist_copy_node(item, &old_item);
+ }
+ }
+ return;
}
void plist_dict_insert_item(plist_t node, const char* key, plist_t item)
{
- if (node && PLIST_DICT == plist_get_node_type(node)) {
- g_node_append(node, plist_new_key(key));
- g_node_append(node, item);
- }
- return;
+ if (node && PLIST_DICT == plist_get_node_type(node))
+ {
+ g_node_append(node, plist_new_key(key));
+ g_node_append(node, item);
+ }
+ return;
}
void plist_dict_remove_item(plist_t node, const char* key)
{
- if (node && PLIST_DICT == plist_get_node_type(node)) {
- plist_t old_item = plist_dict_get_item(node, key);
- if (old_item) {
- plist_t key_node = g_node_prev_sibling(old_item);
- plist_free(key_node);
- plist_free(old_item);
- }
- }
- return;
+ if (node && PLIST_DICT == plist_get_node_type(node))
+ {
+ plist_t old_item = plist_dict_get_item(node, key);
+ if (old_item)
+ {
+ plist_t key_node = g_node_prev_sibling(old_item);
+ plist_free(key_node);
+ plist_free(old_item);
+ }
+ }
+ return;
}
static char compare_node_value(plist_type type, plist_data_t data, const void *value, uint64_t length)
{
- char res = FALSE;
- switch (type) {
- case PLIST_BOOLEAN:
- res = data->boolval == *((char *) value) ? TRUE : FALSE;
- break;
- case PLIST_UINT:
- res = data->intval == *((uint64_t *) value) ? TRUE : FALSE;
- break;
- case PLIST_REAL:
- res = data->realval == *((double *) value) ? TRUE : FALSE;
- break;
- case PLIST_KEY:
- case PLIST_STRING:
- res = !strcmp(data->strval, ((char *) value));
- break;
- case PLIST_DATA:
- res = !memcmp(data->buff, (char *) value, length);
- break;
- case PLIST_DATE:
- res = !memcmp(&(data->timeval), value, sizeof(GTimeVal));
- break;
- case PLIST_ARRAY:
- case PLIST_DICT:
- default:
- break;
- }
- return res;
+ char res = FALSE;
+ switch (type)
+ {
+ case PLIST_BOOLEAN:
+ res = data->boolval == *((char *) value) ? TRUE : FALSE;
+ break;
+ case PLIST_UINT:
+ res = data->intval == *((uint64_t *) value) ? TRUE : FALSE;
+ break;
+ case PLIST_REAL:
+ res = data->realval == *((double *) value) ? TRUE : FALSE;
+ break;
+ case PLIST_KEY:
+ case PLIST_STRING:
+ res = !strcmp(data->strval, ((char *) value));
+ break;
+ case PLIST_DATA:
+ res = !memcmp(data->buff, (char *) value, length);
+ break;
+ case PLIST_DATE:
+ res = !memcmp(&(data->timeval), value, sizeof(GTimeVal));
+ break;
+ case PLIST_ARRAY:
+ case PLIST_DICT:
+ default:
+ break;
+ }
+ return res;
}
plist_t plist_access_pathv(plist_t plist, uint32_t length, va_list v)
{
- plist_t current = plist;
- plist_type type = PLIST_NONE;
- uint32_t i = 0;
-
- for (i = 0; i < length && current; i++) {
- type = plist_get_node_type(current);
-
- if (type == PLIST_ARRAY) {
- uint32_t index = va_arg(v, uint32_t);
- current = plist_array_get_item(current, index);
- }
- else if (type == PLIST_DICT) {
- const char* key = va_arg(v, const char*);
- current = plist_dict_get_item(current, key);
- }
- }
- return current;
+ plist_t current = plist;
+ plist_type type = PLIST_NONE;
+ uint32_t i = 0;
+
+ for (i = 0; i < length && current; i++)
+ {
+ type = plist_get_node_type(current);
+
+ if (type == PLIST_ARRAY)
+ {
+ uint32_t index = va_arg(v, uint32_t);
+ current = plist_array_get_item(current, index);
+ }
+ else if (type == PLIST_DICT)
+ {
+ const char* key = va_arg(v, const char*);
+ current = plist_dict_get_item(current, key);
+ }
+ }
+ return current;
}
plist_t plist_access_path(plist_t plist, uint32_t length, ...)
{
- plist_t ret = NULL;
- va_list v;
-
- va_start(v, length);
- ret = plist_access_pathv(plist, length, v);
- va_end(v);
- return ret;
+ plist_t ret = NULL;
+ va_list v;
+
+ va_start(v, length);
+ ret = plist_access_pathv(plist, length, v);
+ va_end(v);
+ return ret;
}
static void plist_get_type_and_value(plist_t node, plist_type * type, void *value, uint64_t * length)
{
- plist_data_t data = NULL;
-
- if (!node)
- return;
-
- data = plist_get_data(node);
-
- *type = data->type;
- *length = data->length;
-
- switch (*type) {
- case PLIST_BOOLEAN:
- *((char *) value) = data->boolval;
- break;
- case PLIST_UINT:
- *((uint64_t *) value) = data->intval;
- break;
- case PLIST_REAL:
- *((double *) value) = data->realval;
- break;
- case PLIST_KEY:
- case PLIST_STRING:
- *((char **) value) = strdup(data->strval);
- break;
- case PLIST_DATA:
- *((uint8_t **) value) = (uint8_t *) malloc(*length * sizeof(uint8_t));
- memcpy(*((uint8_t **) value), data->buff, *length * sizeof(uint8_t));
- break;
- case PLIST_DATE:
- //exception : here we use memory on the stack since it is just a temporary buffer
- ((GTimeVal *) value)->tv_sec = data->timeval.tv_sec;
- ((GTimeVal *) value)->tv_usec = data->timeval.tv_usec;
- break;
- case PLIST_ARRAY:
- case PLIST_DICT:
- default:
- break;
- }
+ plist_data_t data = NULL;
+
+ if (!node)
+ return;
+
+ data = plist_get_data(node);
+
+ *type = data->type;
+ *length = data->length;
+
+ switch (*type)
+ {
+ case PLIST_BOOLEAN:
+ *((char *) value) = data->boolval;
+ break;
+ case PLIST_UINT:
+ *((uint64_t *) value) = data->intval;
+ break;
+ case PLIST_REAL:
+ *((double *) value) = data->realval;
+ break;
+ case PLIST_KEY:
+ case PLIST_STRING:
+ *((char **) value) = strdup(data->strval);
+ break;
+ case PLIST_DATA:
+ *((uint8_t **) value) = (uint8_t *) malloc(*length * sizeof(uint8_t));
+ memcpy(*((uint8_t **) value), data->buff, *length * sizeof(uint8_t));
+ break;
+ case PLIST_DATE:
+ //exception : here we use memory on the stack since it is just a temporary buffer
+ ((GTimeVal *) value)->tv_sec = data->timeval.tv_sec;
+ ((GTimeVal *) value)->tv_usec = data->timeval.tv_usec;
+ break;
+ case PLIST_ARRAY:
+ case PLIST_DICT:
+ default:
+ break;
+ }
}
plist_t plist_get_parent(plist_t node)
{
- return node ? (plist_t) ((GNode *) node)->parent : NULL;
+ return node ? (plist_t) ((GNode *) node)->parent : NULL;
}
plist_type plist_get_node_type(plist_t node)
{
- if (node) {
- plist_data_t data = plist_get_data(node);
- if (data)
- return data->type;
- }
- return PLIST_NONE;
+ if (node)
+ {
+ plist_data_t data = plist_get_data(node);
+ if (data)
+ return data->type;
+ }
+ return PLIST_NONE;
}
void plist_get_key_val(plist_t node, char **val)
{
- plist_type type = plist_get_node_type(node);
- uint64_t length = 0;
- if (PLIST_KEY == type)
- plist_get_type_and_value(node, &type, (void *) val, &length);
- assert(length == strlen(*val));
+ plist_type type = plist_get_node_type(node);
+ uint64_t length = 0;
+ if (PLIST_KEY == type)
+ plist_get_type_and_value(node, &type, (void *) val, &length);
+ assert(length == strlen(*val));
}
void plist_get_string_val(plist_t node, char **val)
{
- plist_type type = plist_get_node_type(node);
- uint64_t length = 0;
- if (PLIST_STRING == type)
- plist_get_type_and_value(node, &type, (void *) val, &length);
- assert(length == strlen(*val));
+ plist_type type = plist_get_node_type(node);
+ uint64_t length = 0;
+ if (PLIST_STRING == type)
+ plist_get_type_and_value(node, &type, (void *) val, &length);
+ assert(length == strlen(*val));
}
void plist_get_bool_val(plist_t node, uint8_t * val)
{
- plist_type type = plist_get_node_type(node);
- uint64_t length = 0;
- if (PLIST_BOOLEAN == type)
- plist_get_type_and_value(node, &type, (void *) val, &length);
- assert(length == sizeof(uint8_t));
+ plist_type type = plist_get_node_type(node);
+ uint64_t length = 0;
+ if (PLIST_BOOLEAN == type)
+ plist_get_type_and_value(node, &type, (void *) val, &length);
+ assert(length == sizeof(uint8_t));
}
void plist_get_uint_val(plist_t node, uint64_t * val)
{
- plist_type type = plist_get_node_type(node);
- uint64_t length = 0;
- if (PLIST_UINT == type)
- plist_get_type_and_value(node, &type, (void *) val, &length);
- assert(length == sizeof(uint64_t));
+ plist_type type = plist_get_node_type(node);
+ uint64_t length = 0;
+ if (PLIST_UINT == type)
+ plist_get_type_and_value(node, &type, (void *) val, &length);
+ assert(length == sizeof(uint64_t));
}
void plist_get_real_val(plist_t node, double *val)
{
- plist_type type = plist_get_node_type(node);
- uint64_t length = 0;
- if (PLIST_REAL == type)
- plist_get_type_and_value(node, &type, (void *) val, &length);
- assert(length == sizeof(double));
+ plist_type type = plist_get_node_type(node);
+ uint64_t length = 0;
+ if (PLIST_REAL == type)
+ plist_get_type_and_value(node, &type, (void *) val, &length);
+ assert(length == sizeof(double));
}
void plist_get_data_val(plist_t node, char **val, uint64_t * length)
{
- plist_type type = plist_get_node_type(node);
- if (PLIST_DATA == type)
- plist_get_type_and_value(node, &type, (void *) val, length);
+ plist_type type = plist_get_node_type(node);
+ if (PLIST_DATA == type)
+ plist_get_type_and_value(node, &type, (void *) val, length);
}
void plist_get_date_val(plist_t node, int32_t * sec, int32_t * usec)
{
- plist_type type = plist_get_node_type(node);
- uint64_t length = 0;
- GTimeVal val = { 0, 0 };
- if (PLIST_DATE == type)
- plist_get_type_and_value(node, &type, (void *) &val, &length);
- assert(length == sizeof(GTimeVal));
- *sec = val.tv_sec;
- *usec = val.tv_usec;
+ plist_type type = plist_get_node_type(node);
+ uint64_t length = 0;
+ GTimeVal val = { 0, 0 };
+ if (PLIST_DATE == type)
+ plist_get_type_and_value(node, &type, (void *) &val, &length);
+ assert(length == sizeof(GTimeVal));
+ *sec = val.tv_sec;
+ *usec = val.tv_usec;
}
gboolean plist_data_compare(gconstpointer a, gconstpointer b)
{
- plist_data_t val_a = NULL;
- plist_data_t val_b = NULL;
-
- if (!a || !b)
- return FALSE;
-
- if (!((GNode *) a)->data || !((GNode *) b)->data)
- return FALSE;
-
- val_a = plist_get_data((plist_t) a);
- val_b = plist_get_data((plist_t) b);
-
- if (val_a->type != val_b->type)
- return FALSE;
-
- switch (val_a->type) {
- case PLIST_BOOLEAN:
- case PLIST_UINT:
- case PLIST_REAL:
- if (val_a->intval == val_b->intval) //it is an union so this is sufficient
- return TRUE;
- else
- return FALSE;
-
- case PLIST_KEY:
- case PLIST_STRING:
- if (!strcmp(val_a->strval, val_b->strval))
- return TRUE;
- else
- return FALSE;
-
- case PLIST_DATA:
- if (!memcmp(val_a->buff, val_b->buff, val_a->length))
- return TRUE;
- else
- return FALSE;
- case PLIST_ARRAY:
- case PLIST_DICT:
- //compare pointer
- if (a == b)
- return TRUE;
- else
- return FALSE;
- break;
- case PLIST_DATE:
- if (!memcmp(&(val_a->timeval), &(val_b->timeval), sizeof(GTimeVal)))
- return TRUE;
- else
- return FALSE;
- default:
- break;
- }
- return FALSE;
+ plist_data_t val_a = NULL;
+ plist_data_t val_b = NULL;
+
+ if (!a || !b)
+ return FALSE;
+
+ if (!((GNode *) a)->data || !((GNode *) b)->data)
+ return FALSE;
+
+ val_a = plist_get_data((plist_t) a);
+ val_b = plist_get_data((plist_t) b);
+
+ if (val_a->type != val_b->type)
+ return FALSE;
+
+ switch (val_a->type)
+ {
+ case PLIST_BOOLEAN:
+ case PLIST_UINT:
+ case PLIST_REAL:
+ if (val_a->intval == val_b->intval) //it is an union so this is sufficient
+ return TRUE;
+ else
+ return FALSE;
+
+ case PLIST_KEY:
+ case PLIST_STRING:
+ if (!strcmp(val_a->strval, val_b->strval))
+ return TRUE;
+ else
+ return FALSE;
+
+ case PLIST_DATA:
+ if (!memcmp(val_a->buff, val_b->buff, val_a->length))
+ return TRUE;
+ else
+ return FALSE;
+ case PLIST_ARRAY:
+ case PLIST_DICT:
+ //compare pointer
+ if (a == b)
+ return TRUE;
+ else
+ return FALSE;
+ break;
+ case PLIST_DATE:
+ if (!memcmp(&(val_a->timeval), &(val_b->timeval), sizeof(GTimeVal)))
+ return TRUE;
+ else
+ return FALSE;
+ default:
+ break;
+ }
+ return FALSE;
}
char plist_compare_node_value(plist_t node_l, plist_t node_r)
{
- return plist_data_compare(node_l, node_r);
+ return plist_data_compare(node_l, node_r);
}
static void plist_set_element_val(plist_t node, plist_type type, const void *value, uint64_t length)
{
- //free previous allocated buffer
- plist_data_t data = plist_get_data(node);
- assert(data); // a node should always have data attached
-
- switch (data->type) {
- case PLIST_KEY:
- case PLIST_STRING:
- free(data->strval);
- data->strval = NULL;
- break;
- case PLIST_DATA:
- free(data->buff);
- data->buff = NULL;
- break;
- default:
- break;
- }
-
- //now handle value
-
- data->type = type;
- data->length = length;
-
- switch (type) {
- case PLIST_BOOLEAN:
- data->boolval = *((char *) value);
- break;
- case PLIST_UINT:
- data->intval = *((uint64_t *) value);
- break;
- case PLIST_REAL:
- data->realval = *((double *) value);
- break;
- case PLIST_KEY:
- case PLIST_STRING:
- data->strval = strdup((char *) value);
- break;
- case PLIST_DATA:
- data->buff = (uint8_t *) malloc(length);
- memcpy(data->buff, value, length);
- break;
- case PLIST_DATE:
- data->timeval.tv_sec = ((GTimeVal *) value)->tv_sec;
- data->timeval.tv_usec = ((GTimeVal *) value)->tv_usec;
- break;
- case PLIST_ARRAY:
- case PLIST_DICT:
- default:
- break;
- }
+ //free previous allocated buffer
+ plist_data_t data = plist_get_data(node);
+ assert(data); // a node should always have data attached
+
+ switch (data->type)
+ {
+ case PLIST_KEY:
+ case PLIST_STRING:
+ free(data->strval);
+ data->strval = NULL;
+ break;
+ case PLIST_DATA:
+ free(data->buff);
+ data->buff = NULL;
+ break;
+ default:
+ break;
+ }
+
+ //now handle value
+
+ data->type = type;
+ data->length = length;
+
+ switch (type)
+ {
+ case PLIST_BOOLEAN:
+ data->boolval = *((char *) value);
+ break;
+ case PLIST_UINT:
+ data->intval = *((uint64_t *) value);
+ break;
+ case PLIST_REAL:
+ data->realval = *((double *) value);
+ break;
+ case PLIST_KEY:
+ case PLIST_STRING:
+ data->strval = strdup((char *) value);
+ break;
+ case PLIST_DATA:
+ data->buff = (uint8_t *) malloc(length);
+ memcpy(data->buff, value, length);
+ break;
+ case PLIST_DATE:
+ data->timeval.tv_sec = ((GTimeVal *) value)->tv_sec;
+ data->timeval.tv_usec = ((GTimeVal *) value)->tv_usec;
+ break;
+ case PLIST_ARRAY:
+ case PLIST_DICT:
+ default:
+ break;
+ }
}
void plist_set_type(plist_t node, plist_type type)
{
- if ( g_node_n_children(node) == 0 ) {
- plist_data_t data = plist_get_data(node);
- plist_free_data( data );
- data = plist_new_plist_data();
- data->type = type;
- switch(type){
- case PLIST_BOOLEAN:
- data->length = sizeof(uint8_t);
- break;
- case PLIST_UINT:
- data->length = sizeof(uint64_t);
- break;
- case PLIST_REAL:
- data->length = sizeof(double);
- break;
- case PLIST_DATE:
- data->length = sizeof(GTimeVal);
- break;
- default:
- data->length = 0;
- break;
- }
- }
+ if ( g_node_n_children(node) == 0 )
+ {
+ plist_data_t data = plist_get_data(node);
+ plist_free_data( data );
+ data = plist_new_plist_data();
+ data->type = type;
+ switch (type)
+ {
+ case PLIST_BOOLEAN:
+ data->length = sizeof(uint8_t);
+ break;
+ case PLIST_UINT:
+ data->length = sizeof(uint64_t);
+ break;
+ case PLIST_REAL:
+ data->length = sizeof(double);
+ break;
+ case PLIST_DATE:
+ data->length = sizeof(GTimeVal);
+ break;
+ default:
+ data->length = 0;
+ break;
+ }
+ }
}
void plist_set_key_val(plist_t node, const char *val)
{
- plist_set_element_val(node, PLIST_KEY, val, strlen(val));
+ plist_set_element_val(node, PLIST_KEY, val, strlen(val));
}
void plist_set_string_val(plist_t node, const char *val)
{
- plist_set_element_val(node, PLIST_STRING, val, strlen(val));
+ plist_set_element_val(node, PLIST_STRING, val, strlen(val));
}
void plist_set_bool_val(plist_t node, uint8_t val)
{
- plist_set_element_val(node, PLIST_BOOLEAN, &val, sizeof(uint8_t));
+ plist_set_element_val(node, PLIST_BOOLEAN, &val, sizeof(uint8_t));
}
void plist_set_uint_val(plist_t node, uint64_t val)
{
- plist_set_element_val(node, PLIST_UINT, &val, sizeof(uint64_t));
+ plist_set_element_val(node, PLIST_UINT, &val, sizeof(uint64_t));
}
void plist_set_real_val(plist_t node, double val)
{
- plist_set_element_val(node, PLIST_REAL, &val, sizeof(double));
+ plist_set_element_val(node, PLIST_REAL, &val, sizeof(double));
}
void plist_set_data_val(plist_t node, const char *val, uint64_t length)
{
- plist_set_element_val(node, PLIST_DATA, val, length);
+ plist_set_element_val(node, PLIST_DATA, val, length);
}
void plist_set_date_val(plist_t node, int32_t sec, int32_t usec)
{
- GTimeVal val = { sec, usec };
- plist_set_element_val(node, PLIST_DATE, &val, sizeof(GTimeVal));
+ GTimeVal val = { sec, usec };
+ plist_set_element_val(node, PLIST_DATE, &val, sizeof(GTimeVal));
}
//DEPRECATED API BELOW
@@ -748,176 +791,187 @@ void plist_set_date_val(plist_t node, int32_t sec, int32_t usec)
static plist_t plist_add_sub_element(plist_t node, plist_type type, const void *value, uint64_t length)
{
- //only structured types can have children
- plist_type node_type = plist_get_node_type(node);
- if (node_type == PLIST_DICT || node_type == PLIST_ARRAY) {
- //only structured types are allowed to have nulll value
- if (value || (!value && (type == PLIST_DICT || type == PLIST_ARRAY))) {
-
- plist_t subnode = NULL;
-
- //now handle value
- plist_data_t data = plist_new_plist_data();
- data->type = type;
- data->length = length;
-
- switch (type) {
- case PLIST_BOOLEAN:
- data->boolval = *((char *) value);
- break;
- case PLIST_UINT:
- data->intval = *((uint64_t *) value);
- break;
- case PLIST_REAL:
- data->realval = *((double *) value);
- break;
- case PLIST_KEY:
- case PLIST_STRING:
- data->strval = strdup((char *) value);
- break;
- case PLIST_DATA:
- data->buff = (uint8_t *) malloc(length);
- memcpy(data->buff, value, length);
- break;
- case PLIST_DATE:
- data->timeval.tv_sec = ((GTimeVal *) value)->tv_sec;
- data->timeval.tv_usec = ((GTimeVal *) value)->tv_usec;
- break;
- case PLIST_ARRAY:
- case PLIST_DICT:
- default:
- break;
- }
-
- subnode = plist_new_node(data);
- if (node)
- g_node_append(node, subnode);
- return subnode;
- } else
- return NULL;
- }
- return NULL;
+ //only structured types can have children
+ plist_type node_type = plist_get_node_type(node);
+ if (node_type == PLIST_DICT || node_type == PLIST_ARRAY)
+ {
+ //only structured types are allowed to have nulll value
+ if (value || (!value && (type == PLIST_DICT || type == PLIST_ARRAY)))
+ {
+
+ plist_t subnode = NULL;
+
+ //now handle value
+ plist_data_t data = plist_new_plist_data();
+ data->type = type;
+ data->length = length;
+
+ switch (type)
+ {
+ case PLIST_BOOLEAN:
+ data->boolval = *((char *) value);
+ break;
+ case PLIST_UINT:
+ data->intval = *((uint64_t *) value);
+ break;
+ case PLIST_REAL:
+ data->realval = *((double *) value);
+ break;
+ case PLIST_KEY:
+ case PLIST_STRING:
+ data->strval = strdup((char *) value);
+ break;
+ case PLIST_DATA:
+ data->buff = (uint8_t *) malloc(length);
+ memcpy(data->buff, value, length);
+ break;
+ case PLIST_DATE:
+ data->timeval.tv_sec = ((GTimeVal *) value)->tv_sec;
+ data->timeval.tv_usec = ((GTimeVal *) value)->tv_usec;
+ break;
+ case PLIST_ARRAY:
+ case PLIST_DICT:
+ default:
+ break;
+ }
+
+ subnode = plist_new_node(data);
+ if (node)
+ g_node_append(node, subnode);
+ return subnode;
+ }
+ else
+ return NULL;
+ }
+ return NULL;
}
plist_t plist_get_first_child(plist_t node)
{
- return (plist_t) g_node_first_child((GNode *) node);
+ return (plist_t) g_node_first_child((GNode *) node);
}
plist_t plist_get_next_sibling(plist_t node)
{
- return (plist_t) g_node_next_sibling((GNode *) node);
+ return (plist_t) g_node_next_sibling((GNode *) node);
}
plist_t plist_get_prev_sibling(plist_t node)
{
- return (plist_t) g_node_prev_sibling((GNode *) node);
+ return (plist_t) g_node_prev_sibling((GNode *) node);
}
plist_t plist_get_array_nth_el(plist_t node, uint32_t n)
{
- plist_t ret = NULL;
- if (node && PLIST_ARRAY == plist_get_node_type(node)) {
- uint32_t i = 0;
- plist_t temp = plist_get_first_child(node);
+ plist_t ret = NULL;
+ if (node && PLIST_ARRAY == plist_get_node_type(node))
+ {
+ uint32_t i = 0;
+ plist_t temp = plist_get_first_child(node);
- while (i <= n && temp) {
- if (i == n)
- ret = temp;
- temp = plist_get_next_sibling(temp);
- i++;
- }
- }
- return ret;
+ while (i <= n && temp)
+ {
+ if (i == n)
+ ret = temp;
+ temp = plist_get_next_sibling(temp);
+ i++;
+ }
+ }
+ return ret;
}
plist_t plist_get_dict_el_from_key(plist_t node, const char *key)
{
- plist_t ret = NULL;
- if (node && PLIST_DICT == plist_get_node_type(node)) {
+ plist_t ret = NULL;
+ if (node && PLIST_DICT == plist_get_node_type(node))
+ {
- plist_t key_node = plist_find_node_by_key(node, key);
- ret = plist_get_next_sibling(key_node);
- }
- return ret;
+ plist_t key_node = plist_find_node_by_key(node, key);
+ ret = plist_get_next_sibling(key_node);
+ }
+ return ret;
}
void plist_add_sub_node(plist_t node, plist_t subnode)
{
- if (node && subnode) {
- plist_type type = plist_get_node_type(node);
- if (type == PLIST_DICT || type == PLIST_ARRAY)
- g_node_append(node, subnode);
- }
+ if (node && subnode)
+ {
+ plist_type type = plist_get_node_type(node);
+ if (type == PLIST_DICT || type == PLIST_ARRAY)
+ g_node_append(node, subnode);
+ }
}
void plist_add_sub_key_el(plist_t node, const char *val)
{
- plist_add_sub_element(node, PLIST_KEY, val, strlen(val));
+ plist_add_sub_element(node, PLIST_KEY, val, strlen(val));
}
void plist_add_sub_string_el(plist_t node, const char *val)
{
- plist_add_sub_element(node, PLIST_STRING, val, strlen(val));
+ plist_add_sub_element(node, PLIST_STRING, val, strlen(val));
}
void plist_add_sub_bool_el(plist_t node, uint8_t val)
{
- plist_add_sub_element(node, PLIST_BOOLEAN, &val, sizeof(uint8_t));
+ plist_add_sub_element(node, PLIST_BOOLEAN, &val, sizeof(uint8_t));
}
void plist_add_sub_uint_el(plist_t node, uint64_t val)
{
- plist_add_sub_element(node, PLIST_UINT, &val, sizeof(uint64_t));
+ plist_add_sub_element(node, PLIST_UINT, &val, sizeof(uint64_t));
}
void plist_add_sub_real_el(plist_t node, double val)
{
- plist_add_sub_element(node, PLIST_REAL, &val, sizeof(double));
+ plist_add_sub_element(node, PLIST_REAL, &val, sizeof(double));
}
void plist_add_sub_data_el(plist_t node, const char *val, uint64_t length)
{
- plist_add_sub_element(node, PLIST_DATA, val, length);
+ plist_add_sub_element(node, PLIST_DATA, val, length);
}
void plist_add_sub_date_el(plist_t node, int32_t sec, int32_t usec)
{
- GTimeVal val = { sec, usec };
- plist_add_sub_element(node, PLIST_DATE, &val, sizeof(GTimeVal));
+ GTimeVal val = { sec, usec };
+ plist_add_sub_element(node, PLIST_DATE, &val, sizeof(GTimeVal));
}
static plist_t plist_find_node(plist_t plist, plist_type type, const void *value, uint64_t length)
{
- plist_t current = NULL;
+ plist_t current = NULL;
- if (!plist)
- return NULL;
+ if (!plist)
+ return NULL;
- for (current = (plist_t)g_node_first_child(plist); current; current = (plist_t)g_node_next_sibling(current)) {
+ for (current = (plist_t)g_node_first_child(plist); current; current = (plist_t)g_node_next_sibling(current))
+ {
- plist_data_t data = plist_get_data(current);
+ plist_data_t data = plist_get_data(current);
- if (data->type == type && data->length == length && compare_node_value(type, data, value, length)) {
- return current;
- }
- if (data->type == PLIST_DICT || data->type == PLIST_ARRAY) {
- plist_t sub = plist_find_node(current, type, value, length);
- if (sub)
- return sub;
- }
- }
- return NULL;
+ if (data->type == type && data->length == length && compare_node_value(type, data, value, length))
+ {
+ return current;
+ }
+ if (data->type == PLIST_DICT || data->type == PLIST_ARRAY)
+ {
+ plist_t sub = plist_find_node(current, type, value, length);
+ if (sub)
+ return sub;
+ }
+ }
+ return NULL;
}
plist_t plist_find_node_by_key(plist_t plist, const char *value)
{
- return plist_find_node(plist, PLIST_KEY, value, strlen(value));
+ return plist_find_node(plist, PLIST_KEY, value, strlen(value));
}
plist_t plist_find_node_by_string(plist_t plist, const char *value)
{
- return plist_find_node(plist, PLIST_STRING, value, strlen(value));
+ return plist_find_node(plist, PLIST_STRING, value, strlen(value));
}
diff --git a/src/plist.h b/src/plist.h
index b642d74..b9f12d5 100644
--- a/src/plist.h
+++ b/src/plist.h
@@ -8,15 +8,15 @@
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef PLIST_H
@@ -35,17 +35,19 @@
#endif
-struct plist_data_s {
- union {
- char boolval;
- uint64_t intval;
- double realval;
- char *strval;
- uint8_t *buff;
- GTimeVal timeval;
- };
- uint64_t length;
- plist_type type;
+struct plist_data_s
+{
+ union
+ {
+ char boolval;
+ uint64_t intval;
+ double realval;
+ char *strval;
+ uint8_t *buff;
+ GTimeVal timeval;
+ };
+ uint64_t length;
+ plist_type type;
};
typedef struct plist_data_s *plist_data_t;
diff --git a/src/xplist.c b/src/xplist.c
index 490367e..15c9497 100644
--- a/src/xplist.c
+++ b/src/xplist.c
@@ -8,15 +8,15 @@
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
@@ -50,7 +50,7 @@ static const char *plist_base = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\
/** Formats a block of text to be a given indentation and width.
- *
+ *
* The total width of the return string will be depth + cols.
*
* @param buf The string to format.
@@ -61,303 +61,323 @@ static const char *plist_base = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\
*/
static gchar *format_string(const char *buf, int cols, int depth)
{
- int colw = depth + cols + 1;
- int len = strlen(buf);
- int nlines = len / cols + 1;
- gchar *new_buf = (gchar *) g_malloc0(nlines * colw + depth + 1);
- int i = 0;
- int j = 0;
-
- assert(cols >= 0);
- assert(depth >= 0);
-
- // Inserts new lines and tabs at appropriate locations
- for (i = 0; i < nlines; i++) {
- new_buf[i * colw] = '\n';
- for (j = 0; j < depth; j++)
- new_buf[i * colw + 1 + j] = '\t';
- memcpy(new_buf + i * colw + 1 + depth, buf + i * cols, (i + 1) * cols <= len ? cols : len - i * cols);
- }
- new_buf[len + (1 + depth) * nlines] = '\n';
-
- // Inserts final row of indentation and termination character
- for (j = 0; j < depth; j++)
- new_buf[len + (1 + depth) * nlines + 1 + j] = '\t';
- new_buf[len + (1 + depth) * nlines + depth + 1] = '\0';
-
- return new_buf;
+ int colw = depth + cols + 1;
+ int len = strlen(buf);
+ int nlines = len / cols + 1;
+ gchar *new_buf = (gchar *) g_malloc0(nlines * colw + depth + 1);
+ int i = 0;
+ int j = 0;
+
+ assert(cols >= 0);
+ assert(depth >= 0);
+
+ // Inserts new lines and tabs at appropriate locations
+ for (i = 0; i < nlines; i++)
+ {
+ new_buf[i * colw] = '\n';
+ for (j = 0; j < depth; j++)
+ new_buf[i * colw + 1 + j] = '\t';
+ memcpy(new_buf + i * colw + 1 + depth, buf + i * cols, (i + 1) * cols <= len ? cols : len - i * cols);
+ }
+ new_buf[len + (1 + depth) * nlines] = '\n';
+
+ // Inserts final row of indentation and termination character
+ for (j = 0; j < depth; j++)
+ new_buf[len + (1 + depth) * nlines + 1 + j] = '\t';
+ new_buf[len + (1 + depth) * nlines + depth + 1] = '\0';
+
+ return new_buf;
}
-struct xml_node {
- xmlNodePtr xml;
- uint32_t depth;
+struct xml_node
+{
+ xmlNodePtr xml;
+ uint32_t depth;
};
/** Creates a new plist XML document.
- *
+ *
* @return The plist XML document.
*/
static xmlDocPtr new_xml_plist(void)
{
- char *plist = strdup(plist_base);
- xmlDocPtr plist_xml = xmlParseMemory(plist, strlen(plist));
+ char *plist = strdup(plist_base);
+ xmlDocPtr plist_xml = xmlParseMemory(plist, strlen(plist));
- if (!plist_xml)
- return NULL;
+ if (!plist_xml)
+ return NULL;
- free(plist);
+ free(plist);
- return plist_xml;
+ return plist_xml;
}
static void node_to_xml(GNode * node, gpointer xml_struct)
{
- struct xml_node *xstruct = NULL;
- plist_data_t node_data = NULL;
-
- xmlNodePtr child_node = NULL;
- char isStruct = FALSE;
-
- const xmlChar *tag = NULL;
- gchar *val = NULL;
-
- //for base64
- gchar *valtmp = NULL;
-
- uint32_t i = 0;
-
- if (!node)
- return;
-
- xstruct = (struct xml_node *) xml_struct;
- node_data = plist_get_data(node);
-
- switch (node_data->type) {
- case PLIST_BOOLEAN:
- {
- if (node_data->boolval)
- tag = XPLIST_TRUE;
- else
- tag = XPLIST_FALSE;
- }
- break;
-
- case PLIST_UINT:
- tag = XPLIST_INT;
- val = g_strdup_printf("%llu", node_data->intval);
- break;
-
- case PLIST_REAL:
- tag = XPLIST_REAL;
- val = g_strdup_printf("%f", node_data->realval);
- break;
-
- case PLIST_STRING:
- tag = XPLIST_STRING;
- val = g_strdup(node_data->strval);
- break;
-
- case PLIST_KEY:
- tag = XPLIST_KEY;
- val = g_strdup((gchar *) node_data->strval);
- break;
-
- case PLIST_DATA:
- tag = XPLIST_DATA;
- if (node_data->length) {
- valtmp = g_base64_encode(node_data->buff, node_data->length);
- val = format_string(valtmp, 60, xstruct->depth);
- g_free(valtmp);
- }
- break;
- case PLIST_ARRAY:
- tag = XPLIST_ARRAY;
- isStruct = TRUE;
- break;
- case PLIST_DICT:
- tag = XPLIST_DICT;
- isStruct = TRUE;
- break;
- case PLIST_DATE:
- tag = XPLIST_DATE;
- val = g_time_val_to_iso8601(&node_data->timeval);
- break;
- default:
- break;
- }
-
- for (i = 0; i < xstruct->depth; i++) {
- xmlNodeAddContent(xstruct->xml, BAD_CAST("\t"));
- }
- child_node = xmlNewChild(xstruct->xml, NULL, tag, BAD_CAST(val));
- xmlNodeAddContent(xstruct->xml, BAD_CAST("\n"));
- g_free(val);
-
- //add return for structured types
- if (node_data->type == PLIST_ARRAY || node_data->type == PLIST_DICT)
- xmlNodeAddContent(child_node, BAD_CAST("\n"));
-
- if (isStruct) {
- struct xml_node child = { child_node, xstruct->depth + 1 };
- g_node_children_foreach(node, G_TRAVERSE_ALL, node_to_xml, &child);
- }
- //fix indent for structured types
- if (node_data->type == PLIST_ARRAY || node_data->type == PLIST_DICT) {
-
- for (i = 0; i < xstruct->depth; i++) {
- xmlNodeAddContent(child_node, BAD_CAST("\t"));
- }
- }
-
- return;
+ struct xml_node *xstruct = NULL;
+ plist_data_t node_data = NULL;
+
+ xmlNodePtr child_node = NULL;
+ char isStruct = FALSE;
+
+ const xmlChar *tag = NULL;
+ gchar *val = NULL;
+
+ //for base64
+ gchar *valtmp = NULL;
+
+ uint32_t i = 0;
+
+ if (!node)
+ return;
+
+ xstruct = (struct xml_node *) xml_struct;
+ node_data = plist_get_data(node);
+
+ switch (node_data->type)
+ {
+ case PLIST_BOOLEAN:
+ {
+ if (node_data->boolval)
+ tag = XPLIST_TRUE;
+ else
+ tag = XPLIST_FALSE;
+ }
+ break;
+
+ case PLIST_UINT:
+ tag = XPLIST_INT;
+ val = g_strdup_printf("%llu", node_data->intval);
+ break;
+
+ case PLIST_REAL:
+ tag = XPLIST_REAL;
+ val = g_strdup_printf("%f", node_data->realval);
+ break;
+
+ case PLIST_STRING:
+ tag = XPLIST_STRING;
+ val = g_strdup(node_data->strval);
+ break;
+
+ case PLIST_KEY:
+ tag = XPLIST_KEY;
+ val = g_strdup((gchar *) node_data->strval);
+ break;
+
+ case PLIST_DATA:
+ tag = XPLIST_DATA;
+ if (node_data->length)
+ {
+ valtmp = g_base64_encode(node_data->buff, node_data->length);
+ val = format_string(valtmp, 60, xstruct->depth);
+ g_free(valtmp);
+ }
+ break;
+ case PLIST_ARRAY:
+ tag = XPLIST_ARRAY;
+ isStruct = TRUE;
+ break;
+ case PLIST_DICT:
+ tag = XPLIST_DICT;
+ isStruct = TRUE;
+ break;
+ case PLIST_DATE:
+ tag = XPLIST_DATE;
+ val = g_time_val_to_iso8601(&node_data->timeval);
+ break;
+ default:
+ break;
+ }
+
+ for (i = 0; i < xstruct->depth; i++)
+ {
+ xmlNodeAddContent(xstruct->xml, BAD_CAST("\t"));
+ }
+ child_node = xmlNewChild(xstruct->xml, NULL, tag, BAD_CAST(val));
+ xmlNodeAddContent(xstruct->xml, BAD_CAST("\n"));
+ g_free(val);
+
+ //add return for structured types
+ if (node_data->type == PLIST_ARRAY || node_data->type == PLIST_DICT)
+ xmlNodeAddContent(child_node, BAD_CAST("\n"));
+
+ if (isStruct)
+ {
+ struct xml_node child = { child_node, xstruct->depth + 1 };
+ g_node_children_foreach(node, G_TRAVERSE_ALL, node_to_xml, &child);
+ }
+ //fix indent for structured types
+ if (node_data->type == PLIST_ARRAY || node_data->type == PLIST_DICT)
+ {
+
+ for (i = 0; i < xstruct->depth; i++)
+ {
+ xmlNodeAddContent(child_node, BAD_CAST("\t"));
+ }
+ }
+
+ return;
}
static void xml_to_node(xmlNodePtr xml_node, plist_t * plist_node)
{
- xmlNodePtr node = NULL;
- plist_data_t data = NULL;
- plist_t subnode = NULL;
-
- //for string
- glong len = 0;
- int type = 0;
-
- if (!xml_node)
- return;
-
- for (node = xml_node->children; node; node = node->next) {
-
- while (node && !xmlStrcmp(node->name, XPLIST_TEXT))
- node = node->next;
- if (!node)
- break;
-
- data = plist_new_plist_data();
- subnode = plist_new_node(data);
- if (*plist_node)
- g_node_append(*plist_node, subnode);
- else
- *plist_node = subnode;
-
- if (!xmlStrcmp(node->name, XPLIST_TRUE)) {
- data->boolval = TRUE;
- data->type = PLIST_BOOLEAN;
- data->length = 1;
- continue;
- }
-
- if (!xmlStrcmp(node->name, XPLIST_FALSE)) {
- data->boolval = FALSE;
- data->type = PLIST_BOOLEAN;
- data->length = 1;
- continue;
- }
-
- if (!xmlStrcmp(node->name, XPLIST_INT)) {
- xmlChar *strval = xmlNodeGetContent(node);
- data->intval = g_ascii_strtoull((char *) strval, NULL, 0);
- data->type = PLIST_UINT;
- data->length = 8;
- xmlFree(strval);
- continue;
- }
-
- if (!xmlStrcmp(node->name, XPLIST_REAL)) {
- xmlChar *strval = xmlNodeGetContent(node);
- data->realval = atof((char *) strval);
- data->type = PLIST_REAL;
- data->length = 8;
- xmlFree(strval);
- continue;
- }
-
- if (!xmlStrcmp(node->name, XPLIST_DATE)) {
- xmlChar *strval = xmlNodeGetContent(node);
- g_time_val_from_iso8601((char *) strval, &data->timeval);
- data->type = PLIST_DATE;
- data->length = sizeof(GTimeVal);
- xmlFree(strval);
- continue;
- }
-
- if (!xmlStrcmp(node->name, XPLIST_STRING)) {
- xmlChar *strval = xmlNodeGetContent(node);
- len = strlen((char *) strval);
- type = xmlDetectCharEncoding(strval, len);
-
- if (XML_CHAR_ENCODING_UTF8 == type || XML_CHAR_ENCODING_ASCII == type || XML_CHAR_ENCODING_NONE == type) {
- data->strval = strdup((char *) strval);
- data->type = PLIST_STRING;
- data->length = strlen(data->strval);
- }
- xmlFree(strval);
- continue;
- }
-
- if (!xmlStrcmp(node->name, XPLIST_KEY)) {
- xmlChar *strval = xmlNodeGetContent(node);
- data->strval = strdup((char *) strval);
- data->type = PLIST_KEY;
- data->length = strlen(data->strval);
- xmlFree(strval);
- continue;
- }
-
- if (!xmlStrcmp(node->name, XPLIST_DATA)) {
- xmlChar *strval = xmlNodeGetContent(node);
- gsize size = 0;
- guchar *dec = g_base64_decode((char *) strval, &size);
- data->buff = (uint8_t *) malloc(size * sizeof(uint8_t));
- memcpy(data->buff, dec, size * sizeof(uint8_t));
- g_free(dec);
- data->length = size;
- data->type = PLIST_DATA;
- xmlFree(strval);
- continue;
- }
-
- if (!xmlStrcmp(node->name, XPLIST_ARRAY)) {
- data->type = PLIST_ARRAY;
- xml_to_node(node, &subnode);
- continue;
- }
-
- if (!xmlStrcmp(node->name, XPLIST_DICT)) {
- data->type = PLIST_DICT;
- xml_to_node(node, &subnode);
- continue;
- }
- }
+ xmlNodePtr node = NULL;
+ plist_data_t data = NULL;
+ plist_t subnode = NULL;
+
+ //for string
+ glong len = 0;
+ int type = 0;
+
+ if (!xml_node)
+ return;
+
+ for (node = xml_node->children; node; node = node->next)
+ {
+
+ while (node && !xmlStrcmp(node->name, XPLIST_TEXT))
+ node = node->next;
+ if (!node)
+ break;
+
+ data = plist_new_plist_data();
+ subnode = plist_new_node(data);
+ if (*plist_node)
+ g_node_append(*plist_node, subnode);
+ else
+ *plist_node = subnode;
+
+ if (!xmlStrcmp(node->name, XPLIST_TRUE))
+ {
+ data->boolval = TRUE;
+ data->type = PLIST_BOOLEAN;
+ data->length = 1;
+ continue;
+ }
+
+ if (!xmlStrcmp(node->name, XPLIST_FALSE))
+ {
+ data->boolval = FALSE;
+ data->type = PLIST_BOOLEAN;
+ data->length = 1;
+ continue;
+ }
+
+ if (!xmlStrcmp(node->name, XPLIST_INT))
+ {
+ xmlChar *strval = xmlNodeGetContent(node);
+ data->intval = g_ascii_strtoull((char *) strval, NULL, 0);
+ data->type = PLIST_UINT;
+ data->length = 8;
+ xmlFree(strval);
+ continue;
+ }
+
+ if (!xmlStrcmp(node->name, XPLIST_REAL))
+ {
+ xmlChar *strval = xmlNodeGetContent(node);
+ data->realval = atof((char *) strval);
+ data->type = PLIST_REAL;
+ data->length = 8;
+ xmlFree(strval);
+ continue;
+ }
+
+ if (!xmlStrcmp(node->name, XPLIST_DATE))
+ {
+ xmlChar *strval = xmlNodeGetContent(node);
+ g_time_val_from_iso8601((char *) strval, &data->timeval);
+ data->type = PLIST_DATE;
+ data->length = sizeof(GTimeVal);
+ xmlFree(strval);
+ continue;
+ }
+
+ if (!xmlStrcmp(node->name, XPLIST_STRING))
+ {
+ xmlChar *strval = xmlNodeGetContent(node);
+ len = strlen((char *) strval);
+ type = xmlDetectCharEncoding(strval, len);
+
+ if (XML_CHAR_ENCODING_UTF8 == type || XML_CHAR_ENCODING_ASCII == type || XML_CHAR_ENCODING_NONE == type)
+ {
+ data->strval = strdup((char *) strval);
+ data->type = PLIST_STRING;
+ data->length = strlen(data->strval);
+ }
+ xmlFree(strval);
+ continue;
+ }
+
+ if (!xmlStrcmp(node->name, XPLIST_KEY))
+ {
+ xmlChar *strval = xmlNodeGetContent(node);
+ data->strval = strdup((char *) strval);
+ data->type = PLIST_KEY;
+ data->length = strlen(data->strval);
+ xmlFree(strval);
+ continue;
+ }
+
+ if (!xmlStrcmp(node->name, XPLIST_DATA))
+ {
+ xmlChar *strval = xmlNodeGetContent(node);
+ gsize size = 0;
+ guchar *dec = g_base64_decode((char *) strval, &size);
+ data->buff = (uint8_t *) malloc(size * sizeof(uint8_t));
+ memcpy(data->buff, dec, size * sizeof(uint8_t));
+ g_free(dec);
+ data->length = size;
+ data->type = PLIST_DATA;
+ xmlFree(strval);
+ continue;
+ }
+
+ if (!xmlStrcmp(node->name, XPLIST_ARRAY))
+ {
+ data->type = PLIST_ARRAY;
+ xml_to_node(node, &subnode);
+ continue;
+ }
+
+ if (!xmlStrcmp(node->name, XPLIST_DICT))
+ {
+ data->type = PLIST_DICT;
+ xml_to_node(node, &subnode);
+ continue;
+ }
+ }
}
void plist_to_xml(plist_t plist, char **plist_xml, uint32_t * length)
{
- xmlDocPtr plist_doc = NULL;
- xmlNodePtr root_node = NULL;
- struct xml_node root = { NULL, 0 };
- int size = 0;
-
- if (!plist || !plist_xml || *plist_xml)
- return;
- plist_doc = new_xml_plist();
- root_node = xmlDocGetRootElement(plist_doc);
- root.xml = root_node;
-
- node_to_xml(plist, &root);
-
- xmlDocDumpMemory(plist_doc, (xmlChar **) plist_xml, &size);
- if (size >= 0)
- *length = size;
- xmlFreeDoc(plist_doc);
+ xmlDocPtr plist_doc = NULL;
+ xmlNodePtr root_node = NULL;
+ struct xml_node root = { NULL, 0 };
+ int size = 0;
+
+ if (!plist || !plist_xml || *plist_xml)
+ return;
+ plist_doc = new_xml_plist();
+ root_node = xmlDocGetRootElement(plist_doc);
+ root.xml = root_node;
+
+ node_to_xml(plist, &root);
+
+ xmlDocDumpMemory(plist_doc, (xmlChar **) plist_xml, &size);
+ if (size >= 0)
+ *length = size;
+ xmlFreeDoc(plist_doc);
}
void plist_from_xml(const char *plist_xml, uint32_t length, plist_t * plist)
{
- xmlDocPtr plist_doc = xmlParseMemory(plist_xml, length);
- xmlNodePtr root_node = xmlDocGetRootElement(plist_doc);
+ xmlDocPtr plist_doc = xmlParseMemory(plist_xml, length);
+ xmlNodePtr root_node = xmlDocGetRootElement(plist_doc);
- xml_to_node(root_node, plist);
- xmlFreeDoc(plist_doc);
+ xml_to_node(root_node, plist);
+ xmlFreeDoc(plist_doc);
}