From a3c6acf863f1a4deef76b0075c36f20de8d31197 Mon Sep 17 00:00:00 2001 From: Jonathan Beck Date: Sun, 4 Jan 2009 16:51:53 +0100 Subject: more warning fixes. --- configure.ac | 2 +- src/bplist.c | 66 +++++++++++++++++++++++++------------------ src/plist.h | 2 +- src/xplist.c | 91 +++++++++++++++++++++++++++++++++++------------------------- 4 files changed, 94 insertions(+), 67 deletions(-) diff --git a/configure.ac b/configure.ac index 4af0e49..2f171e1 100644 --- a/configure.ac +++ b/configure.ac @@ -45,7 +45,7 @@ if test "$no_debug_code" = true; then AC_DEFINE(STRIP_DEBUG_CODE,1,[Strip debug reporting code]) fi -AS_COMPILER_FLAGS(GLOBAL_CFLAGS, "-Wall -Wextra -Wmissing-declarations -Wredundant-decls -Wshadow -Wpointer-arith -Wwrite-strings -Wswitch-default") +AS_COMPILER_FLAGS(GLOBAL_CFLAGS, "-Wall -Wextra -Wmissing-declarations -Wredundant-decls -Wshadow -Wpointer-arith -Wwrite-strings -Wswitch-default -Wno-unused-parameter") AC_SUBST(GLOBAL_CFLAGS) AC_OUTPUT(Makefile src/Makefile include/Makefile plutil/Makefile libplist-1.0.pc) diff --git a/src/bplist.c b/src/bplist.c index ed381db..7a7225d 100644 --- a/src/bplist.c +++ b/src/bplist.c @@ -27,10 +27,10 @@ #include /* Magic marker and size. */ -#define BPLIST_MAGIC "bplist" +#define BPLIST_MAGIC ((uint8_t*)"bplist") #define BPLIST_MAGIC_SIZE 6 -#define BPLIST_VERSION "00" +#define BPLIST_VERSION ((uint8_t*)"00") #define BPLIST_VERSION_SIZE 2 @@ -59,11 +59,11 @@ enum { BPLIST_MASK = 0xF0 }; -static void byte_convert(char *address, size_t size) +static void byte_convert(uint8_t *address, size_t size) { #if G_BYTE_ORDER == G_LITTLE_ENDIAN uint8_t i = 0, j = 0; - char tmp = '\0'; + uint8_t tmp = 0; for (i = 0; i < (size / 2); i++) { tmp = address[i]; @@ -75,13 +75,18 @@ static void byte_convert(char *address, size_t size) } #define swap_n_bytes(x, n) \ - n == 8 ? GUINT64_FROM_BE( *(uint64_t *)(x) ) : \ + (n == 8 ? GUINT64_FROM_BE( *(uint64_t *)(x) ) : \ (n == 4 ? GUINT32_FROM_BE( *(uint32_t *)(x) ) : \ - (n == 2 ? GUINT16_FROM_BE( *(uint16_t *)(x) ) : *(uint8_t *)(x) )) + (n == 2 ? GUINT16_FROM_BE( *(uint16_t *)(x) ) : \ + *(uint8_t *)(x) ))) #define be64dec(x) GUINT64_FROM_BE( *(uint64_t*)(x) ) -#define get_needed_bytes(x) (x <= 1<<8 ? 1 : ( x <= 1<<16 ? 2 : ( x <= (uint64_t)1<<32 ? 4 : 8))) +#define get_needed_bytes(x) \ + ( ((uint64_t)x) < (1ULL << 8) ? 1 : \ + ( ((uint64_t)x) < (1ULL << 16) ? 2 : \ + ( ((uint64_t)x) < (1ULL << 32) ? 4 : 8))) + #define get_real_bytes(x) (x >> 32 ? 4 : 8) @@ -118,12 +123,8 @@ static plist_t parse_real_node(char *bnode, uint8_t size) size = 1 << size; // make length less misleading switch (size) { case sizeof(float): - memcpy(&data->realval, bnode, size); - byte_convert((char *) &data->realval, size); - break; case sizeof(double): - memcpy(&data->realval, bnode, size); - byte_convert((char *) &data->realval, size); + data->realval = swap_n_bytes(bnode, size); break; default: free(data); @@ -163,8 +164,8 @@ static plist_t parse_data_node(char *bnode, uint64_t size) data->type = PLIST_DATA; data->length = size; - data->buff = (char *) malloc(sizeof(char) * size); - memcpy(data->buff, bnode, sizeof(char) * size); + data->buff = (uint8_t *) malloc(sizeof(uint8_t) * size); + memcpy(data->buff, bnode, sizeof(uint8_t) * size); return g_node_new(data); } @@ -175,8 +176,8 @@ static plist_t parse_dict_node(char *bnode, uint64_t size, uint32_t ref_size) data->type = PLIST_DICT; data->length = size; - data->buff = (char *) malloc(sizeof(char) * size * ref_size * 2); - memcpy(data->buff, bnode, sizeof(char) * size * ref_size * 2); + 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); } @@ -187,8 +188,8 @@ static plist_t parse_array_node(char *bnode, uint64_t size, uint32_t ref_size) data->type = PLIST_ARRAY; data->length = size; - data->buff = (char *) malloc(sizeof(char) * size * ref_size); - memcpy(data->buff, bnode, sizeof(char) * size * ref_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); } @@ -321,12 +322,12 @@ static gpointer copy_plist_data(gconstpointer src, gpointer data) break; case PLIST_DATA: case PLIST_ARRAY: - dstdata->buff = (char *) malloc(sizeof(char *) * srcdata->length); - memcpy(dstdata->buff, srcdata->buff, sizeof(char *) * srcdata->length); + 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 = (char *) malloc(sizeof(char *) * srcdata->length * 2); - memcpy(dstdata->buff, srcdata->buff, sizeof(char *) * srcdata->length * 2); + 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; @@ -561,7 +562,9 @@ static void serialize_plist(GNode * node, gpointer data) return; } //insert new ref - g_hash_table_insert(ser->ref_table, node, GUINT_TO_POINTER(current_index)); + uint64_t* 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); @@ -571,6 +574,12 @@ static void serialize_plist(GNode * node, gpointer data) return; } +static gboolean free_index (gpointer key, gpointer value, gpointer user_data) +{ + 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) @@ -619,7 +628,7 @@ static void write_data(GByteArray * bplist, uint8_t * val, uint64_t size) static void write_string(GByteArray * bplist, char *val) { uint64_t size = strlen(val); - write_raw_data(bplist, BPLIST_STRING, val, size); + write_raw_data(bplist, BPLIST_STRING, (uint8_t*) val, size); } static void write_array(GByteArray * bplist, GNode * node, GHashTable * ref_table, uint8_t dict_param_size) @@ -640,7 +649,7 @@ static void write_array(GByteArray * bplist, GNode * node, GHashTable * ref_tabl GNode *cur = NULL; uint64_t i = 0; for (i = 0, cur = node->children; cur && i < size; cur = cur->next, i++) { - idx = GPOINTER_TO_UINT(g_hash_table_lookup(ref_table, cur)); + 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); } @@ -747,7 +756,7 @@ void plist_to_bin(plist_t plist, char **plist_bin, uint32_t * length) //TODO break; case PLIST_DATA: - write_data(bplist_buff, data->strval, data->length); + 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; @@ -762,6 +771,9 @@ void plist_to_bin(plist_t plist, char **plist_bin, uint32_t * length) } } + //free intermediate objects + g_hash_table_foreach_remove (ref_table, free_index, NULL); + //write offsets offset_size = get_needed_bytes(bplist_buff->len); offset_table_index = bplist_buff->len; @@ -778,7 +790,7 @@ void plist_to_bin(plist_t plist, char **plist_bin, uint32_t * length) root_object = GUINT64_FROM_BE(root_object); offset_table_index = GUINT64_FROM_BE(offset_table_index); - char trailer[BPLIST_TRL_SIZE]; + uint8_t trailer[BPLIST_TRL_SIZE]; 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)); diff --git a/src/plist.h b/src/plist.h index a637118..8428597 100644 --- a/src/plist.h +++ b/src/plist.h @@ -43,7 +43,7 @@ struct plist_data_s { double realval; char *strval; wchar_t *unicodeval; - char *buff; + uint8_t *buff; }; uint64_t length; plist_type type; diff --git a/src/xplist.c b/src/xplist.c index abc448d..3487f96 100644 --- a/src/xplist.c +++ b/src/xplist.c @@ -32,6 +32,17 @@ #include #include +#define XPLIST_TEXT BAD_CAST("text") +#define XPLIST_KEY BAD_CAST("key") +#define XPLIST_FALSE BAD_CAST("false") +#define XPLIST_TRUE BAD_CAST("true") +#define XPLIST_INT BAD_CAST("integer") +#define XPLIST_REAL BAD_CAST("real") +#define XPLIST_DATE BAD_CAST("date") +#define XPLIST_DATA BAD_CAST("data") +#define XPLIST_STRING BAD_CAST("string") +#define XPLIST_ARRAY BAD_CAST("array") +#define XPLIST_DICT BAD_CAST("dict") const char *plist_base = "\n\ \n\ @@ -125,56 +136,56 @@ static void node_to_xml(GNode * node, gpointer xml_struct) xmlNodePtr child_node = NULL; char isStruct = FALSE; - const gchar *tag = NULL; - const gchar *val = NULL; + const xmlChar *tag = NULL; + gchar *val = NULL; switch (node_data->type) { case PLIST_BOOLEAN: { if (node_data->boolval) - tag = "true"; + tag = XPLIST_TRUE; else - tag = "false"; + tag = XPLIST_FALSE; } break; case PLIST_UINT: - tag = "integer"; + tag = XPLIST_INT; val = g_strdup_printf("%lu", (long unsigned int) node_data->intval); break; case PLIST_REAL: - tag = "real"; + tag = XPLIST_REAL; val = g_strdup_printf("%Lf", (long double) node_data->realval); break; case PLIST_STRING: - tag = "string"; + tag = XPLIST_STRING; val = g_strdup(node_data->strval); break; case PLIST_UNICODE: - tag = "string"; + tag = XPLIST_STRING; val = g_strdup((gchar *) node_data->unicodeval); break; case PLIST_KEY: - tag = "key"; + tag = XPLIST_KEY; val = g_strdup((gchar *) node_data->strval); break; case PLIST_DATA: - tag = "data"; + tag = XPLIST_DATA; gchar *valtmp = g_base64_encode(node_data->buff, node_data->length); val = format_string(valtmp, 68, xstruct->depth); g_free(valtmp); break; case PLIST_ARRAY: - tag = "array"; + tag = XPLIST_ARRAY; isStruct = TRUE; break; case PLIST_DICT: - tag = "dict"; + tag = XPLIST_DICT; isStruct = TRUE; break; case PLIST_DATE: //TODO : handle date tag @@ -182,17 +193,17 @@ static void node_to_xml(GNode * node, gpointer xml_struct) break; } - int i = 0; + uint32_t i = 0; for (i = 0; i < xstruct->depth; i++) { - xmlNodeAddContent(xstruct->xml, "\t"); + xmlNodeAddContent(xstruct->xml, BAD_CAST("\t")); } - child_node = xmlNewChild(xstruct->xml, NULL, tag, val); - xmlNodeAddContent(xstruct->xml, "\n"); + 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, "\n"); + xmlNodeAddContent(child_node, BAD_CAST("\n")); if (isStruct) { struct xml_node child = { child_node, xstruct->depth + 1 }; @@ -202,20 +213,20 @@ static void node_to_xml(GNode * node, gpointer xml_struct) if (node_data->type == PLIST_ARRAY || node_data->type == PLIST_DICT) { for (i = 0; i < xstruct->depth; i++) { - xmlNodeAddContent(child_node, "\t"); + xmlNodeAddContent(child_node, BAD_CAST("\t")); } } return; } -void xml_to_node(xmlNodePtr xml_node, plist_t * plist_node) +static void xml_to_node(xmlNodePtr xml_node, plist_t * plist_node) { xmlNodePtr node = NULL; for (node = xml_node->children; node; node = node->next) { - while (node && !xmlStrcmp(node->name, "text")) + while (node && !xmlStrcmp(node->name, XPLIST_TEXT)) node = node->next; if (!node) break; @@ -227,68 +238,68 @@ void xml_to_node(xmlNodePtr xml_node, plist_t * plist_node) else *plist_node = subnode; - if (!xmlStrcmp(node->name, "true")) { - data->boolval = 1; + if (!xmlStrcmp(node->name, XPLIST_TRUE)) { + data->boolval = TRUE; data->type = PLIST_BOOLEAN; data->length = 1; continue; } - if (!xmlStrcmp(node->name, "false")) { - data->boolval = 0; + if (!xmlStrcmp(node->name, XPLIST_FALSE)) { + data->boolval = FALSE; data->type = PLIST_BOOLEAN; data->length = 1; continue; } - if (!xmlStrcmp(node->name, "integer")) { - char *strval = xmlNodeGetContent(node); + if (!xmlStrcmp(node->name, XPLIST_INT)) { + char *strval = (char*)xmlNodeGetContent(node); data->intval = g_ascii_strtoull(strval, NULL, 0); data->type = PLIST_UINT; data->length = 8; continue; } - if (!xmlStrcmp(node->name, "real")) { - char *strval = xmlNodeGetContent(node); + if (!xmlStrcmp(node->name, XPLIST_REAL)) { + char *strval = (char*)xmlNodeGetContent(node); data->realval = atof(strval); data->type = PLIST_REAL; data->length = 8; continue; } - if (!xmlStrcmp(node->name, "date")) + if (!xmlStrcmp(node->name, XPLIST_DATE)) continue; //TODO : handle date tag - if (!xmlStrcmp(node->name, "string")) { - data->strval = strdup(xmlNodeGetContent(node)); + if (!xmlStrcmp(node->name, XPLIST_STRING)) { + data->strval = strdup( (char*) xmlNodeGetContent(node)); data->type = PLIST_STRING; data->length = strlen(data->strval); continue; } - if (!xmlStrcmp(node->name, "key")) { - data->strval = strdup(xmlNodeGetContent(node)); + if (!xmlStrcmp(node->name, XPLIST_KEY)) { + data->strval = strdup( (char*) xmlNodeGetContent(node)); data->type = PLIST_KEY; data->length = strlen(data->strval); continue; } - if (!xmlStrcmp(node->name, "data")) { + if (!xmlStrcmp(node->name, XPLIST_DATA)) { gsize size = 0; - data->buff = g_base64_decode(xmlNodeGetContent(node), &size); + data->buff = g_base64_decode((char*)xmlNodeGetContent(node), &size); data->length = size; data->type = PLIST_DATA; continue; } - if (!xmlStrcmp(node->name, "array")) { + if (!xmlStrcmp(node->name, XPLIST_ARRAY)) { data->type = PLIST_ARRAY; xml_to_node(node, &subnode); continue; } - if (!xmlStrcmp(node->name, "dict")) { + if (!xmlStrcmp(node->name, XPLIST_DICT)) { data->type = PLIST_DICT; xml_to_node(node, &subnode); continue; @@ -306,7 +317,11 @@ void plist_to_xml(plist_t plist, char **plist_xml, uint32_t * length) node_to_xml(plist, &root); - xmlDocDumpMemory(plist_doc, (xmlChar **) plist_xml, length); + int size = 0; + xmlDocDumpMemory(plist_doc, (xmlChar **) plist_xml, &size); + if (size >=0 ) + *length = size; + free_plist(plist_doc); } void plist_from_xml(const char *plist_xml, uint32_t length, plist_t * plist) -- cgit v1.1-32-gdbae