From aed2c025f6e47dc769675e564cc574adc496a88a Mon Sep 17 00:00:00 2001 From: Jonathan Beck Date: Tue, 25 Nov 2008 19:14:27 +0100 Subject: fix some warnings and indent --- dev/lckdclient.c | 1 + dev/main.c | 2 +- dev/plutil.c | 219 ++++++++++++++++++------------------ src/plist.c | 335 ++++++++++++++++++++++++++++--------------------------- src/plist.h | 11 +- 5 files changed, 294 insertions(+), 274 deletions(-) diff --git a/dev/lckdclient.c b/dev/lckdclient.c index 96bc27d..c96f052 100644 --- a/dev/lckdclient.c +++ b/dev/lckdclient.c @@ -20,6 +20,7 @@ */ #include +#include #include #include #include diff --git a/dev/main.c b/dev/main.c index 2dbfb4a..4974eef 100644 --- a/dev/main.c +++ b/dev/main.c @@ -87,7 +87,7 @@ int main(int argc, char *argv[]) iphone_afc_get_file_attr(afc, "/iTunesOnTheGoPlaylist.plist", &stbuf); if (IPHONE_E_SUCCESS == iphone_afc_open_file(afc, "/iTunesOnTheGoPlaylist.plist", IPHONE_AFC_FILE_READ, &my_file) && my_file) { - printf("A file size: %i\n", stbuf.st_size); + printf("A file size: %i\n", (int) stbuf.st_size); char *file_data = (char *) malloc(sizeof(char) * stbuf.st_size); iphone_afc_read_file(afc, my_file, file_data, stbuf.st_size, &bytes); if (bytes >= 0) { diff --git a/dev/plutil.c b/dev/plutil.c index 1c7b140..d1c3ddd 100644 --- a/dev/plutil.c +++ b/dev/plutil.c @@ -5,171 +5,178 @@ #include "../src/plist.h" #include "plutil.h" +#include +#include +#include +#include -int debug = 0; - -void print_nodes(bplist_node *root_node) { +void print_nodes(bplist_node * root_node) +{ // Yay, great. Let's print the list of nodes recursively... int i = 0; - if (!root_node) return; // or not, because the programmer's stupid. - + if (!root_node) + return; // or not, because the programmer's stupid. + switch (root_node->type) { - case BPLIST_DICT: - printf("Dictionary node.\nLength %i\n", root_node->length); - for (i = 0; i < (root_node->length * 2); i+=2) { - // HI! - printf("Key: "); - print_nodes(root_node->subnodes[i]); - printf("Value: "); - print_nodes(root_node->subnodes[i+1]); - } - printf("End dictionary node.\n\n"); - break; - - case BPLIST_ARRAY: - printf("Array node.\n"); - for (i = 0; i < root_node->length; i++) { - printf("\tElement %i: ", i); - print_nodes(root_node->subnodes[i]); - } - break; - - case BPLIST_INT: - if (root_node->length == sizeof(uint8_t)) { - printf("Integer: %i\n", root_node->intval8); - } else if (root_node->length == sizeof(uint16_t)) { - printf("Integer: %i\n", root_node->intval16); - } else if (root_node->length == sizeof(uint32_t)) { - printf("Integer: %i\n", root_node->intval32); - } - break; - - case BPLIST_STRING: - printf("String: "); - fwrite(root_node->strval, sizeof(char), root_node->length, stdout); - fflush(stdout); - printf("\n"); - break; - - case BPLIST_DATA: - printf("Data: "); - char* data = g_base64_encode(root_node->strval,root_node->length); - fwrite(format_string(data, 60, 0), sizeof(char), strlen(data), stdout); - fflush(stdout); - printf("\n"); - break; - - case BPLIST_UNICODE: - printf("Unicode data, may appear crappy: "); - fwrite(root_node->unicodeval, sizeof(wchar_t), root_node->length, stdout); - fflush(stdout); - printf("\n"); - break; - - case BPLIST_TRUE: - printf("True.\n"); - break; - - case BPLIST_FALSE: - printf("False.\n"); - break; - - case BPLIST_REAL: - case BPLIST_DATE: - printf("Real(?): %f\n", root_node->realval); - break; - - default: - printf("oops\nType set to %x and length is %i\n", root_node->type, root_node->length); - break; + case BPLIST_DICT: + printf("Dictionary node.\nLength %lu\n", (long unsigned int) root_node->length); + for (i = 0; i < (root_node->length * 2); i += 2) { + // HI! + printf("Key: "); + print_nodes(root_node->subnodes[i]); + printf("Value: "); + print_nodes(root_node->subnodes[i + 1]); + } + printf("End dictionary node.\n\n"); + break; + + case BPLIST_ARRAY: + printf("Array node.\n"); + for (i = 0; i < root_node->length; i++) { + printf("\tElement %i: ", i); + print_nodes(root_node->subnodes[i]); + } + break; + + case BPLIST_INT: + if (root_node->length == sizeof(uint8_t)) { + printf("Integer: %i\n", root_node->intval8); + } else if (root_node->length == sizeof(uint16_t)) { + printf("Integer: %i\n", root_node->intval16); + } else if (root_node->length == sizeof(uint32_t)) { + printf("Integer: %i\n", root_node->intval32); + } + break; + + case BPLIST_STRING: + printf("String: "); + fwrite(root_node->strval, sizeof(char), root_node->length, stdout); + fflush(stdout); + printf("\n"); + break; + + case BPLIST_DATA: + printf("Data: "); + char *data = g_base64_encode(root_node->strval, root_node->length); + fwrite(format_string(data, 60, 0), sizeof(char), strlen(data), stdout); + fflush(stdout); + printf("\n"); + break; + + case BPLIST_UNICODE: + printf("Unicode data, may appear crappy: "); + fwrite(root_node->unicodeval, sizeof(wchar_t), root_node->length, stdout); + fflush(stdout); + printf("\n"); + break; + + case BPLIST_TRUE: + printf("True.\n"); + break; + + case BPLIST_FALSE: + printf("False.\n"); + break; + + case BPLIST_REAL: + case BPLIST_DATE: + printf("Real(?): %f\n", root_node->realval); + break; + + default: + printf("oops\nType set to %x and length is %lu\n", root_node->type, (long unsigned int) root_node->length); + break; } } -int main(int argc, char *argv[]) { - struct stat *filestats = (struct stat *)malloc(sizeof(struct stat)); +int main(int argc, char *argv[]) +{ + struct stat *filestats = (struct stat *) malloc(sizeof(struct stat)); uint32_t position = 0; Options *options = parse_arguments(argc, argv); int argh = 0; - + printf("plistutil version 0.2 written by FxChiP\n"); - + if (!options) { print_usage(); return 0; } - debug = options->debug; - + iphone_set_debug(options->debug); + FILE *bplist = fopen(options->in_file, "r"); - + stat(options->in_file, filestats); printf("here?\n"); - char *bplist_entire = (char*)malloc(sizeof(char) * (filestats->st_size + 1)); + char *bplist_entire = (char *) malloc(sizeof(char) * (filestats->st_size + 1)); //argh = fgets(bplist_entire, filestats->st_size, bplist); argh = fread(bplist_entire, sizeof(char), filestats->st_size, bplist); printf("read %i bytes\n", argh); fclose(bplist); printf("or here?\n"); // bplist_entire contains our stuff - bplist_node *root_node; - root_node = parse_nodes(bplist_entire, filestats->st_size, &position); - printf("plutil debug mode\n\n"); - printf("file size %i\n\n", filestats->st_size); - if (!root_node) { - printf("Invalid binary plist (or some other error occurred.)\n"); - return 0; + bplist_node *root_node; + root_node = parse_nodes(bplist_entire, filestats->st_size, &position); + printf("plutil debug mode\n\n"); + printf("file size %i\n\n", (int) filestats->st_size); + if (!root_node) { + printf("Invalid binary plist (or some other error occurred.)\n"); + return 0; } - print_nodes(root_node); - return 0; - } + print_nodes(root_node); + return 0; +} -Options *parse_arguments(int argc, char *argv[]) { +Options *parse_arguments(int argc, char *argv[]) +{ int i = 0; - - Options *options = (Options*)malloc(sizeof(Options)); + + Options *options = (Options *) malloc(sizeof(Options)); memset(options, 0, sizeof(Options)); - + for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "--infile") || !strcmp(argv[i], "-i")) { - if ((i+1) == argc) { + if ((i + 1) == argc) { free(options); return NULL; } - options->in_file = argv[i+1]; + options->in_file = argv[i + 1]; i++; continue; } - + if (!strcmp(argv[i], "--outfile") || !strcmp(argv[i], "-o")) { - if ((i+1) == argc) { + if ((i + 1) == argc) { free(options); return NULL; } - options->out_file = argv[i+1]; + options->out_file = argv[i + 1]; i++; continue; } - + if (!strcmp(argv[i], "--debug") || !strcmp(argv[i], "-d") || !strcmp(argv[i], "-v")) { options->debug = 1; } - + if (!strcmp(argv[i], "--help") || !strcmp(argv[i], "-h")) { free(options); return NULL; } } - - if (!options->in_file /*|| !options->out_file*/) { + + if (!options->in_file /*|| !options->out_file */ ) { free(options); return NULL; } - + return options; } -void print_usage() { +void print_usage() +{ printf("Usage: plistutil -i|--infile in_file.plist -o|--outfile out_file.plist [--debug]\n"); printf("\n"); printf("\t-i or --infile: The file to read in.\n"); diff --git a/src/plist.c b/src/plist.c index 0024577..7a09b4d 100644 --- a/src/plist.c +++ b/src/plist.c @@ -261,8 +261,10 @@ void free_dictionary(char **dictionary) * - parse_nodes() will return the first node it encounters, which is usually the "root" node. */ -uint32_t uipow(uint32_t value, uint32_t power) { - if (!power) return 1; +uint32_t uipow(uint32_t value, uint32_t power) +{ + if (!power) + return 1; int i = 0, oVal = value; for (i = 1; i < power; i++) { value *= oVal; @@ -270,50 +272,55 @@ uint32_t uipow(uint32_t value, uint32_t power) { return value; } -void byte_convert(char *address, size_t size) { +void byte_convert(char *address, size_t size) +{ int i = 0, j = 0; char tmp = '\0'; - + for (i = 0; i < (size / 2); i++) { tmp = address[i]; - j = ((size-1) + 0) - i; + j = ((size - 1) + 0) - i; address[i] = address[j]; address[j] = tmp; } } - -bplist_node *parse_raw_node(const char *bpbuffer, uint32_t bplength, uint32_t *position, uint8_t ref_size) { - if (!position || !bpbuffer || !bplength) return NULL; - + +bplist_node *parse_raw_node(const char *bpbuffer, uint32_t bplength, uint32_t * position, uint8_t ref_size) +{ + if (!position || !bpbuffer || !bplength) + return NULL; + uint8_t modifier = 0; - bplist_node *new_node = (bplist_node*)malloc(sizeof(bplist_node)); + bplist_node *new_node = (bplist_node *) malloc(sizeof(bplist_node)); bplist_node *length_stupidity = NULL; - memset(new_node, 0, sizeof(bplist_node)); // initialize the new struct - + memset(new_node, 0, sizeof(bplist_node)); // initialize the new struct + int myPos = *position; - if (myPos == bplength || (myPos+1) == bplength) { free(new_node); return NULL; } // end of string - + if (myPos == bplength || (myPos + 1) == bplength) { + free(new_node); + return NULL; + } // end of string + uint32_t length = 0; if (!myPos) { if (strncmp(bpbuffer, "bplist00", strlen("bplist00"))) { - return NULL; // badness! + return NULL; // badness! } myPos += strlen("bplist00"); } - // Get the node's type. - if (bpbuffer[myPos] == BPLIST_DATE) { // handle date separately, but do it as a real + if (bpbuffer[myPos] == BPLIST_DATE) { // handle date separately, but do it as a real // better handling of date; basically interpret as real or double new_node->type = BPLIST_DATE; - new_node->length = 8; // always 8 for "date" (Apple intended it, not me) + new_node->length = 8; // always 8 for "date" (Apple intended it, not me) myPos++; - memcpy(&new_node->realval, bpbuffer+myPos, sizeof(new_node->realval)); - byte_convert(&new_node->realval, sizeof(new_node->realval)); + memcpy(&new_node->realval, bpbuffer + myPos, sizeof(new_node->realval)); + byte_convert((char *) &new_node->realval, sizeof(new_node->realval)); myPos += new_node->length; *position = myPos; return new_node; } - + new_node->type = bpbuffer[myPos] & BPLIST_MASK; new_node->length = bpbuffer[myPos] & BPLIST_FILL; if (!new_node->type) { @@ -322,151 +329,153 @@ bplist_node *parse_raw_node(const char *bpbuffer, uint32_t bplength, uint32_t *p // okay, so it is. Carry on. new_node->type = bpbuffer[myPos]; new_node->length = 0; - } else { + } else { // er, what? we have a bad type here. Return NULL. free(new_node); //printf("parse_raw_node: lol type: type given %x\n", bpbuffer[myPos]); return NULL; } } - - myPos++; // puts us in the data. - if (new_node->length == BPLIST_FILL) { // Data happens to contain length... + + myPos++; // puts us in the data. + if (new_node->length == BPLIST_FILL) { // Data happens to contain length... // what? you're going to make me parse an int for the length. You suck. *position = myPos; length_stupidity = parse_raw_node(bpbuffer, bplength, &myPos, ref_size); switch (length_stupidity->length) { - case sizeof(uint8_t): - new_node->length = length_stupidity->intval8; - break; - case sizeof(uint16_t): - new_node->length = length_stupidity->intval16; - break; - case sizeof(uint32_t): - new_node->length = length_stupidity->intval32; - break; - case sizeof(uint64_t): - new_node->length = length_stupidity->intval64; - break; - default: - free(new_node); - free(length_stupidity); - return NULL; + case sizeof(uint8_t): + new_node->length = length_stupidity->intval8; + break; + case sizeof(uint16_t): + new_node->length = length_stupidity->intval16; + break; + case sizeof(uint32_t): + new_node->length = length_stupidity->intval32; + break; + case sizeof(uint64_t): + new_node->length = length_stupidity->intval64; + break; + default: + free(new_node); + free(length_stupidity); + return NULL; } // There, we have our fucking length now. *position = myPos; - free(length_stupidity); // cleanup + free(length_stupidity); // cleanup } - // Now we're in the data. // Error-checking sorta if ((myPos + new_node->length) >= bplength) { - new_node->length = bplength - myPos; // truncate the object + new_node->length = bplength - myPos; // truncate the object } - // And now for the greatest show on earth: the giant fucking switch statement. switch (new_node->type) { - case BPLIST_INT: - new_node->length = uipow(2, new_node->length); // make length less misleading - switch (new_node->length) { - case sizeof(uint8_t): - new_node->intval8 = bpbuffer[myPos]; - break; - case sizeof(uint16_t): - memcpy(&new_node->intval16, bpbuffer+myPos, sizeof(uint16_t)); - new_node->intval16 = ntohs(new_node->intval16); - break; - case sizeof(uint32_t): - memcpy(&new_node->intval32, bpbuffer+myPos, sizeof(uint32_t)); - new_node->intval32 = ntohl(new_node->intval32); - break; - case sizeof(uint64_t): - memcpy(&new_node->intval64, bpbuffer+myPos, sizeof(uint64_t)); - byte_convert(&new_node->intval64, sizeof(uint64_t)); - break; - default: - free(new_node); - printf("parse_raw_node: lol: invalid int: size given %i\n", new_node->length); - printf("parse_raw_node: lol: by the way sizeof(uint64) = %i\n", sizeof(uint64_t)); - return NULL; - } + case BPLIST_INT: + new_node->length = uipow(2, new_node->length); // make length less misleading + switch (new_node->length) { + case sizeof(uint8_t): + new_node->intval8 = bpbuffer[myPos]; break; - - case BPLIST_REAL: - new_node->length = uipow(2, new_node->length); - memcpy(&new_node->realval, bpbuffer+myPos, new_node->length); // XXX: probable buffer overflow here - //new_node->realval = bpbuffer[myPos]; // why not - byte_convert(&new_node->realval, sizeof(double)); + case sizeof(uint16_t): + memcpy(&new_node->intval16, bpbuffer + myPos, sizeof(uint16_t)); + new_node->intval16 = ntohs(new_node->intval16); break; - - case BPLIST_DICT: /* returning a raw dict, it forward-references, so. */ - new_node->length = new_node->length * 2; // dicts lie - case BPLIST_ARRAY: /* returning a raw array, it forward-references, so. */ - new_node->intval8 = ref_size; // in arrays and dicts, the "ref size" alluded to in the trailer applies, and should be stored in intval8 so as to save space. - case BPLIST_STRING: - case BPLIST_DATA: - default: /* made to hold raw data. */ - modifier = (new_node->intval8 > 0) ? new_node->intval8 : 1; - new_node->strval = (char*)malloc(sizeof(char) * (new_node->length * modifier)); - memcpy(new_node->strval, bpbuffer+myPos, (new_node->length * modifier)); + case sizeof(uint32_t): + memcpy(&new_node->intval32, bpbuffer + myPos, sizeof(uint32_t)); + new_node->intval32 = ntohl(new_node->intval32); break; - - case BPLIST_UNICODE: - new_node->unicodeval = (wchar_t*)malloc(sizeof(wchar_t) * new_node->length); - memcpy(new_node->unicodeval, bpbuffer+myPos, new_node->length); + case sizeof(uint64_t): + memcpy(&new_node->intval64, bpbuffer + myPos, sizeof(uint64_t)); + byte_convert((char *) &new_node->intval64, sizeof(uint64_t)); break; + default: + free(new_node); + printf("parse_raw_node: lol: invalid int: size given %lu\n", (long unsigned int) new_node->length); + printf("parse_raw_node: lol: by the way sizeof(uint64) = %i\n", sizeof(uint64_t)); + return NULL; + } + break; + + case BPLIST_REAL: + new_node->length = uipow(2, new_node->length); + memcpy(&new_node->realval, bpbuffer + myPos, new_node->length); // XXX: probable buffer overflow here + //new_node->realval = bpbuffer[myPos]; // why not + byte_convert((char *) &new_node->realval, sizeof(double)); + break; + + case BPLIST_DICT: /* returning a raw dict, it forward-references, so. */ + new_node->length = new_node->length * 2; // dicts lie + case BPLIST_ARRAY: /* returning a raw array, it forward-references, so. */ + new_node->intval8 = ref_size; // in arrays and dicts, the "ref size" alluded to in the trailer applies, and should be stored in intval8 so as to save space. + case BPLIST_STRING: + case BPLIST_DATA: + default: /* made to hold raw data. */ + modifier = (new_node->intval8 > 0) ? new_node->intval8 : 1; + new_node->strval = (char *) malloc(sizeof(char) * (new_node->length * modifier)); + memcpy(new_node->strval, bpbuffer + myPos, (new_node->length * modifier)); + break; + + case BPLIST_UNICODE: + new_node->unicodeval = (wchar_t *) malloc(sizeof(wchar_t) * new_node->length); + memcpy(new_node->unicodeval, bpbuffer + myPos, new_node->length); + break; } - + myPos += new_node->length; *position = myPos; return new_node; } -void print_bytes(char *val, size_t size) { +void print_bytes(char *val, size_t size) +{ int i = 0; for (i = 0; i < size; i++) { printf("Byte %i: 0x%x\n", i, val[i]); } } -bplist_node *parse_nodes(const char *bpbuffer, uint32_t bplength, uint32_t *position) { +bplist_node *parse_nodes(const char *bpbuffer, uint32_t bplength, uint32_t * position) +{ bplist_node **nodeslist = NULL, **newaddr = NULL; bplist_node *new_node = NULL, *root_node = NULL; - + uint32_t nodeslength = 0; uint8_t offset_size = 0, dict_param_size = 0; - offset_size = bpbuffer[bplength-26]; - dict_param_size = bpbuffer[bplength-25]; + offset_size = bpbuffer[bplength - 26]; + dict_param_size = bpbuffer[bplength - 25]; uint64_t current_offset = 0; //uint64_t num_objects = *(bpbuffer+(bplength-24)), root_object = *(bpbuffer+(bplength-16)), offset_table_index = *(bpbuffer+(bplength-8)); uint64_t num_objects = 0, root_object = 0, offset_table_index = 0; - memcpy(&num_objects, bpbuffer+bplength-24, sizeof(uint64_t)); - memcpy(&root_object, bpbuffer+bplength-16, sizeof(uint64_t)); - memcpy(&offset_table_index, bpbuffer+bplength-8, sizeof(uint64_t)); - byte_convert(&num_objects, sizeof(uint64_t)); - byte_convert(&root_object, sizeof(uint64_t)); - byte_convert(&offset_table_index, sizeof(uint64_t)); - - log_debug_msg("Offset size: %i\nGiven: %i\n", offset_size, bpbuffer[bplength-26]); - log_debug_msg("Ref size: %i\nGiven: %i\n", dict_param_size, bpbuffer[bplength-25]); - log_debug_msg("Number of objects: %lli\nGiven: %llu\n", num_objects, *(bpbuffer+bplength-24)); - log_debug_msg("Root object index: %lli\nGiven: %llu\n", root_object, *(bpbuffer+bplength-16)); - log_debug_msg("Offset table index: %lli\nGiven: %llu\n", offset_table_index, *(bpbuffer+bplength-8)); + memcpy(&num_objects, bpbuffer + bplength - 24, sizeof(uint64_t)); + memcpy(&root_object, bpbuffer + bplength - 16, sizeof(uint64_t)); + memcpy(&offset_table_index, bpbuffer + bplength - 8, sizeof(uint64_t)); + byte_convert((char *) &num_objects, sizeof(uint64_t)); + byte_convert((char *) &root_object, sizeof(uint64_t)); + byte_convert((char *) &offset_table_index, sizeof(uint64_t)); + + log_debug_msg("Offset size: %i\nGiven: %i\n", offset_size, bpbuffer[bplength - 26]); + log_debug_msg("Ref size: %i\nGiven: %i\n", dict_param_size, bpbuffer[bplength - 25]); + log_debug_msg("Number of objects: %lli\nGiven: %llu\n", num_objects, *(bpbuffer + bplength - 24)); + log_debug_msg("Root object index: %lli\nGiven: %llu\n", root_object, *(bpbuffer + bplength - 16)); + log_debug_msg("Offset table index: %lli\nGiven: %llu\n", offset_table_index, *(bpbuffer + bplength - 8)); log_debug_msg("Size of uint64: %i\n", sizeof(uint64_t)); - + int i = 0, j = 0, k = 0, str_i = 0, str_j = 0; uint32_t index1 = 0, index2 = 0; - - nodeslist = (bplist_node**)malloc(sizeof(bplist_node*) * num_objects); - if (!nodeslist) return NULL; + + nodeslist = (bplist_node **) malloc(sizeof(bplist_node *) * num_objects); + if (!nodeslist) + return NULL; for (i = 0; i < num_objects; i++) { - memcpy(¤t_offset, bpbuffer+(offset_table_index+(i*offset_size)), offset_size); + memcpy(¤t_offset, bpbuffer + (offset_table_index + (i * offset_size)), offset_size); //current_offset = (offset_size == 2) ? ntohs(current_offset) : (offset_size == 4) ? ntohl(current_offset) : current_offset; //if (offset_size == 8) byte_convert(¤t_offset, 8); - byte_convert(¤t_offset, (offset_size <= sizeof(current_offset)) ? offset_size : sizeof(current_offset)); + byte_convert((char *) ¤t_offset, + (offset_size <= sizeof(current_offset)) ? offset_size : sizeof(current_offset)); log_debug_msg("parse_nodes: current_offset = %x\n", current_offset); - nodeslist[i] = parse_raw_node(bpbuffer, bplength, ¤t_offset, dict_param_size); + nodeslist[i] = parse_raw_node(bpbuffer, bplength, (uint32_t *) & current_offset, dict_param_size); log_debug_msg("parse_nodes: parse_raw_node done\n"); } @@ -475,55 +484,55 @@ bplist_node *parse_nodes(const char *bpbuffer, uint32_t bplength, uint32_t *posi // set elements for dicts and arrays and leave the rest alone log_debug_msg("parse_nodes: on node %i\n", i); switch (nodeslist[i]->type) { - case BPLIST_DICT: - log_debug_msg("parse_nodes: dictionary found\n"); - nodeslist[i]->subnodes = (bplist_node*)malloc(sizeof(bplist_node) * nodeslist[i]->length); - for (j = 0; j < (nodeslist[i]->length / 2); j++) { - str_i = j * nodeslist[i]->intval8; - str_j = (j + (nodeslist[i]->length / 2)) * nodeslist[i]->intval8; - - memcpy(&index1, nodeslist[i]->strval+str_i, nodeslist[i]->intval8); - memcpy(&index2, nodeslist[i]->strval+str_j, nodeslist[i]->intval8); - //index1 = (dict_param_size == 1) ? index1 : (dict_param_size == 2) ? ntohs(index1) : (dict_param_size == 4) ? ntohl(index1) : index1; - //index2 = (dict_param_size == 1) ? index2 : (dict_param_size == 2) ? ntohs(index2) : (dict_param_size == 4) ? ntohl(index2) : index2; - byte_convert(&index1, (dict_param_size <= sizeof(index1)) ? dict_param_size : sizeof(index2)); - byte_convert(&index2, (dict_param_size <= sizeof(index2)) ? dict_param_size : sizeof(index2)); - //printf("parse_nodes: key index %i value %i\n", index1, index2); - //printf("parse_nodes: key type %x and length %i\n", nodeslist[index1]->type, nodeslist[index1]->length); - //printf("parse_nodes: value type %x and length %i\n", nodeslist[index2]->type, nodeslist[index2]->length); - nodeslist[i]->subnodes[k++] = nodeslist[index1]; - nodeslist[i]->subnodes[k++] = nodeslist[index2]; - } - - nodeslist[i]->length = nodeslist[i]->length / 2; - free(nodeslist[i]->strval); - k = 0; - break; - - case BPLIST_ARRAY: - log_debug_msg("parse_nodes: array found\n"); - nodeslist[i]->subnodes = (bplist_node*)malloc(sizeof(bplist_node) * nodeslist[i]->length); // memory allocation helps a lot when storing data - - for (j = 0; j < nodeslist[i]->length; j++) { - log_debug_msg("parse_nodes: array index %i\n", j); - str_j = j * nodeslist[i]->intval8; - //index1 = nodeslist[i]->strval[j]; - memcpy(&index1, nodeslist[i]->strval+str_j, nodeslist[i]->intval8); - log_debug_msg("parse_nodes: post-memcpy\n"); - //index1 = (dict_param_size == 1) ? index1 : (dict_param_size == 2) ? ntohs(index1) : (dict_param_size == 4) ? ntohl(index1) : index1; - byte_convert(&index1, (dict_param_size <= sizeof(index1)) ? dict_param_size : sizeof(index1)); - log_debug_msg("parse_nodes: post-ntohl\nindex1 = %i\n", index1); - nodeslist[i]->subnodes[j] = nodeslist[index1]; - log_debug_msg("parse_nodes: post-assignment\n"); - } - free(nodeslist[i]->strval); - break; - default: - //printf("lol... type %x\n", nodeslist[i]->type); - break; - } // those are the only two we need to correct for. + case BPLIST_DICT: + log_debug_msg("parse_nodes: dictionary found\n"); + nodeslist[i]->subnodes = (bplist_node **) malloc(sizeof(bplist_node) * nodeslist[i]->length); + for (j = 0; j < (nodeslist[i]->length / 2); j++) { + str_i = j * nodeslist[i]->intval8; + str_j = (j + (nodeslist[i]->length / 2)) * nodeslist[i]->intval8; + + memcpy(&index1, nodeslist[i]->strval + str_i, nodeslist[i]->intval8); + memcpy(&index2, nodeslist[i]->strval + str_j, nodeslist[i]->intval8); + //index1 = (dict_param_size == 1) ? index1 : (dict_param_size == 2) ? ntohs(index1) : (dict_param_size == 4) ? ntohl(index1) : index1; + //index2 = (dict_param_size == 1) ? index2 : (dict_param_size == 2) ? ntohs(index2) : (dict_param_size == 4) ? ntohl(index2) : index2; + byte_convert((char *) &index1, (dict_param_size <= sizeof(index1)) ? dict_param_size : sizeof(index2)); + byte_convert((char *) &index2, (dict_param_size <= sizeof(index2)) ? dict_param_size : sizeof(index2)); + //printf("parse_nodes: key index %i value %i\n", index1, index2); + //printf("parse_nodes: key type %x and length %i\n", nodeslist[index1]->type, nodeslist[index1]->length); + //printf("parse_nodes: value type %x and length %i\n", nodeslist[index2]->type, nodeslist[index2]->length); + nodeslist[i]->subnodes[k++] = nodeslist[index1]; + nodeslist[i]->subnodes[k++] = nodeslist[index2]; + } + + nodeslist[i]->length = nodeslist[i]->length / 2; + free(nodeslist[i]->strval); + k = 0; + break; + + case BPLIST_ARRAY: + log_debug_msg("parse_nodes: array found\n"); + nodeslist[i]->subnodes = (bplist_node **) malloc(sizeof(bplist_node) * nodeslist[i]->length); // memory allocation helps a lot when storing data + + for (j = 0; j < nodeslist[i]->length; j++) { + log_debug_msg("parse_nodes: array index %i\n", j); + str_j = j * nodeslist[i]->intval8; + //index1 = nodeslist[i]->strval[j]; + memcpy(&index1, nodeslist[i]->strval + str_j, nodeslist[i]->intval8); + log_debug_msg("parse_nodes: post-memcpy\n"); + //index1 = (dict_param_size == 1) ? index1 : (dict_param_size == 2) ? ntohs(index1) : (dict_param_size == 4) ? ntohl(index1) : index1; + byte_convert((char *) &index1, (dict_param_size <= sizeof(index1)) ? dict_param_size : sizeof(index1)); + log_debug_msg("parse_nodes: post-ntohl\nindex1 = %i\n", index1); + nodeslist[i]->subnodes[j] = nodeslist[index1]; + log_debug_msg("parse_nodes: post-assignment\n"); + } + free(nodeslist[i]->strval); + break; + default: + //printf("lol... type %x\n", nodeslist[i]->type); + break; + } // those are the only two we need to correct for. } - + root_node = nodeslist[root_object]; return root_node; } diff --git a/src/plist.h b/src/plist.h index 98c7d91..5f31281 100644 --- a/src/plist.h +++ b/src/plist.h @@ -31,6 +31,7 @@ #include #include +char *format_string(const char *buf, int cols, int depth); xmlNode *add_key_dict_node(xmlDocPtr plist, xmlNode * dict, const char *key, const char *value, int depth); xmlNode *add_key_str_dict_element(xmlDocPtr plist, xmlNode * dict, const char *key, const char *value, int depth); xmlNode *add_key_data_dict_element(xmlDocPtr plist, xmlNode * dict, const char *key, const char *value, int depth); @@ -47,7 +48,7 @@ void free_dictionary(char **dictionary); enum { BPLIST_TRUE = 0x08, BPLIST_FALSE = 0x09, - BPLIST_FILL = 0x0F, /* will be used for length grabbing */ + BPLIST_FILL = 0x0F, /* will be used for length grabbing */ BPLIST_INT = 0x10, BPLIST_REAL = 0x20, BPLIST_DATE = 0x33, @@ -62,15 +63,17 @@ enum { }; typedef struct _bplist_node { - struct _bplist_node *next, **subnodes; // subnodes is for arrays, dicts and (potentially) sets. + struct _bplist_node *next, **subnodes; // subnodes is for arrays, dicts and (potentially) sets. uint64_t length, intval64; - uint32_t intval32; // length = subnodes + uint32_t intval32; // length = subnodes uint16_t intval16; uint8_t intval8; - uint8_t type, *indexes; // indexes for array-types; essentially specify the order in which to access for key => value pairs + uint8_t type, *indexes; // indexes for array-types; essentially specify the order in which to access for key => value pairs char *strval; double realval; wchar_t *unicodeval; } bplist_node; +bplist_node *parse_nodes(const char *bpbuffer, uint32_t bplength, uint32_t * position); + #endif -- cgit v1.1-32-gdbae