1 files changed, 529 insertions, 0 deletions

diff --git a/tools/idevicecrashreport.c b/tools/idevicecrashreport.c
new file mode 100644
index 0000000..09bd537
--- /dev/null
+++ b/tools/idevicecrashreport.c
@@ -0,0 +1,529 @@
+/*
+ * idevicecrashreport.c
+ * Simple utility to move crash reports from a device to a local directory.
+ *
+ * Copyright (c) 2014 Martin Szulecki. All Rights Reserved.
+ * Copyright (c) 2014 Nikias Bassen. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * 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
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define TOOL_NAME "idevicecrashreport"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <getopt.h>
+#ifndef WIN32
+#include <signal.h>
+#endif
+#include <libimobiledevice-glue/utils.h>
+
+#include <libimobiledevice/libimobiledevice.h>
+#include <libimobiledevice/lockdown.h>
+#include <libimobiledevice/service.h>
+#include <libimobiledevice/afc.h>
+#include <plist/plist.h>
+
+#ifdef WIN32
+#include <windows.h>
+#define S_IFLNK S_IFREG
+#define S_IFSOCK S_IFREG
+#endif
+
+#define CRASH_REPORT_MOVER_SERVICE "com.apple.crashreportmover"
+#define CRASH_REPORT_COPY_MOBILE_SERVICE "com.apple.crashreportcopymobile"
+
+const char* target_directory = NULL;
+static int extract_raw_crash_reports = 0;
+static int keep_crash_reports = 0;
+
+static int file_exists(const char* path)
+{
+        struct stat tst;
+#ifdef WIN32
+        return (stat(path, &tst) == 0);
+#else
+        return (lstat(path, &tst) == 0);
+#endif
+}
+
+static int extract_raw_crash_report(const char* filename)
+{
+        int res = 0;
+        plist_t report = NULL;
+        char* raw = NULL;
+        char* raw_filename = strdup(filename);
+
+        /* create filename with '.crash' extension */
+        char* p = strrchr(raw_filename, '.');
+        if ((p == NULL) || (strcmp(p, ".plist") != 0)) {
+                free(raw_filename);
+                return res;
+        }
+        strcpy(p, ".crash");
+
+        /* read plist crash report */
+        if (plist_read_from_file(filename, &report, NULL)) {
+                plist_t description_node = plist_dict_get_item(report, "description");
+                if (description_node && plist_get_node_type(description_node) == PLIST_STRING) {
+                        plist_get_string_val(description_node, &raw);
+
+                        if (raw != NULL) {
+                                /* write file */
+                                buffer_write_to_filename(raw_filename, raw, strlen(raw));
+                                free(raw);
+                                res = 1;
+                        }
+                }
+        }
+
+        if (report)
+                plist_free(report);
+
+        if (raw_filename)
+                free(raw_filename);
+
+        return res;
+}
+
+static int afc_client_copy_and_remove_crash_reports(afc_client_t afc, const char* device_directory, const char* host_directory, const char* filename_filter)
+{
+        afc_error_t afc_error;
+        int k;
+        int res = -1;
+        int crash_report_count = 0;
+        uint64_t handle;
+        char source_filename[512];
+        char target_filename[512];
+
+        if (!afc)
+                return res;
+
+        char** list = NULL;
+        afc_error = afc_read_directory(afc, device_directory, &list);
+        if (afc_error != AFC_E_SUCCESS) {
+                fprintf(stderr, "ERROR: Could not read device directory '%s'\n", device_directory);
+                return res;
+        }
+
+        /* ensure we have a trailing slash */
+        strcpy(source_filename, device_directory);
+        if (source_filename[strlen(source_filename)-1] != '/') {
+                strcat(source_filename, "/");
+        }
+        int device_directory_length = strlen(source_filename);
+
+        /* ensure we have a trailing slash */
+        strcpy(target_filename, host_directory);
+        if (target_filename[strlen(target_filename)-1] != '/') {
+                strcat(target_filename, "/");
+        }
+        int host_directory_length = strlen(target_filename);
+
+        /* loop over file entries */
+        for (k = 0; list[k]; k++) {
+                if (!strcmp(list[k], ".") || !strcmp(list[k], "..")) {
+                        continue;
+                }
+
+                char **fileinfo = NULL;
+                struct stat stbuf;
+                memset(&stbuf, '\0', sizeof(struct stat));
+
+                /* assemble absolute source filename */
+                strcpy(((char*)source_filename) + device_directory_length, list[k]);
+
+                /* assemble absolute target filename */
+#ifdef WIN32
+                /* replace every ':' with '-' since ':' is an illegal character for file names in windows */
+                char* current_pos = strchr(list[k], ':');
+                while (current_pos) {
+                        *current_pos = '-';
+                        current_pos = strchr(current_pos, ':');
+                }
+#endif
+                char* p = strrchr(list[k], '.');
+                if (p != NULL && !strncmp(p, ".synced", 7)) {
+                        /* make sure to strip ".synced" extension as seen on iOS 5 */
+                        size_t newlen = p - list[k];
+                        strncpy(((char*)target_filename) + host_directory_length, list[k], newlen);
+                        target_filename[host_directory_length + newlen] = '\0';
+                } else {
+                        strcpy(((char*)target_filename) + host_directory_length, list[k]);
+                }
+
+                /* get file information */
+                afc_get_file_info(afc, source_filename, &fileinfo);
+                if (!fileinfo) {
+                        printf("Failed to read information for '%s'. Skipping...\n", source_filename);
+                        continue;
+                }
+
+                /* parse file information */
+                int i;
+                for (i = 0; fileinfo[i]; i+=2) {
+                        if (!strcmp(fileinfo[i], "st_size")) {
+                                stbuf.st_size = atoll(fileinfo[i+1]);
+                        } else if (!strcmp(fileinfo[i], "st_ifmt")) {
+                                if (!strcmp(fileinfo[i+1], "S_IFREG")) {
+                                        stbuf.st_mode = S_IFREG;
+                                } else if (!strcmp(fileinfo[i+1], "S_IFDIR")) {
+                                        stbuf.st_mode = S_IFDIR;
+                                } else if (!strcmp(fileinfo[i+1], "S_IFLNK")) {
+                                        stbuf.st_mode = S_IFLNK;
+                                } else if (!strcmp(fileinfo[i+1], "S_IFBLK")) {
+                                        stbuf.st_mode = S_IFBLK;
+                                } else if (!strcmp(fileinfo[i+1], "S_IFCHR")) {
+                                        stbuf.st_mode = S_IFCHR;
+                                } else if (!strcmp(fileinfo[i+1], "S_IFIFO")) {
+                                        stbuf.st_mode = S_IFIFO;
+                                } else if (!strcmp(fileinfo[i+1], "S_IFSOCK")) {
+                                        stbuf.st_mode = S_IFSOCK;
+                                }
+                        } else if (!strcmp(fileinfo[i], "st_nlink")) {
+                                stbuf.st_nlink = atoi(fileinfo[i+1]);
+                        } else if (!strcmp(fileinfo[i], "st_mtime")) {
+                                stbuf.st_mtime = (time_t)(atoll(fileinfo[i+1]) / 1000000000);
+                        } else if (!strcmp(fileinfo[i], "LinkTarget")) {
+                                /* report latest crash report filename */
+                                printf("Link: %s\n", (char*)target_filename + strlen(target_directory));
+
+                                /* remove any previous symlink */
+                                if (file_exists(target_filename)) {
+                                        remove(target_filename);
+                                }
+
+#ifndef WIN32
+                                /* use relative filename */
+                                char* b = strrchr(fileinfo[i+1], '/');
+                                if (b == NULL) {
+                                        b = fileinfo[i+1];
+                                } else {
+                                        b++;
+                                }
+
+                                /* create a symlink pointing to latest log */
+                                if (symlink(b, target_filename) < 0) {
+                                        fprintf(stderr, "Can't create symlink to %s\n", b);
+                                }
+#endif
+
+                                if (!keep_crash_reports)
+                                        afc_remove_path(afc, source_filename);
+
+                                res = 0;
+                        }
+                }
+
+                /* free file information */
+                afc_dictionary_free(fileinfo);
+
+                /* recurse into child directories */
+                if (S_ISDIR(stbuf.st_mode)) {
+#ifdef WIN32
+                        mkdir(target_filename);
+#else
+                        mkdir(target_filename, 0755);
+#endif
+                        res = afc_client_copy_and_remove_crash_reports(afc, source_filename, target_filename, filename_filter);
+
+                        /* remove directory from device */
+                        if (!keep_crash_reports)
+                                afc_remove_path(afc, source_filename);
+                } else if (S_ISREG(stbuf.st_mode)) {
+                        if (filename_filter != NULL && strstr(source_filename, filename_filter) == NULL) {
+                                continue;
+                        }
+
+                        /* copy file to host */
+                        afc_error = afc_file_open(afc, source_filename, AFC_FOPEN_RDONLY, &handle);
+                        if(afc_error != AFC_E_SUCCESS) {
+                                if (afc_error == AFC_E_OBJECT_NOT_FOUND) {
+                                        continue;
+                                }
+                                fprintf(stderr, "Unable to open device file '%s' (%d). Skipping...\n", source_filename, afc_error);
+                                continue;
+                        }
+
+                        FILE* output = fopen(target_filename, "wb");
+                        if(output == NULL) {
+                                fprintf(stderr, "Unable to open local file '%s'. Skipping...\n", target_filename);
+                                afc_file_close(afc, handle);
+                                continue;
+                        }
+
+                        printf("%s: %s\n", (keep_crash_reports ? "Copy": "Move") , (char*)target_filename + strlen(target_directory));
+
+                        uint32_t bytes_read = 0;
+                        uint32_t bytes_total = 0;
+                        unsigned char data[0x1000];
+
+                        afc_error = afc_file_read(afc, handle, (char*)data, 0x1000, &bytes_read);
+                        while(afc_error == AFC_E_SUCCESS && bytes_read > 0) {
+                                fwrite(data, 1, bytes_read, output);
+                                bytes_total += bytes_read;
+                                afc_error = afc_file_read(afc, handle, (char*)data, 0x1000, &bytes_read);
+                        }
+                        afc_file_close(afc, handle);
+                        fclose(output);
+
+                        if ((uint32_t)stbuf.st_size != bytes_total) {
+                                fprintf(stderr, "File size mismatch. Skipping...\n");
+                                continue;
+                        }
+
+                        /* remove file from device */
+                        if (!keep_crash_reports) {
+                                afc_remove_path(afc, source_filename);
+                        }
+
+                        /* extract raw crash information into separate '.crash' file */
+                        if (extract_raw_crash_reports) {
+                                extract_raw_crash_report(target_filename);
+                        }
+
+                        crash_report_count++;
+
+                        res = 0;
+                }
+        }
+        afc_dictionary_free(list);
+
+        /* no reports, no error */
+        if (crash_report_count == 0)
+                res = 0;
+
+        return res;
+}
+
+static void print_usage(int argc, char **argv, int is_error)
+{
+        char *name = strrchr(argv[0], '/');
+        fprintf(is_error ? stderr : stdout, "Usage: %s [OPTIONS] DIRECTORY\n", (name ? name + 1: argv[0]));
+        fprintf(is_error ? stderr : stdout,
+                "\n"
+                "Move crash reports from device to a local DIRECTORY.\n"
+                "\n"
+                "OPTIONS:\n"
+                "  -u, --udid UDID       target specific device by UDID\n"
+                "  -n, --network         connect to network device\n"
+                "  -e, --extract         extract raw crash report into separate '.crash' file\n"
+                "  -k, --keep            copy but do not remove crash reports from device\n"
+                "  -d, --debug           enable communication debugging\n"
+                "  -f, --filter NAME     filter crash reports by NAME (case sensitive)\n"
+                "  -h, --help            prints usage information\n"
+                "  -v, --version         prints version information\n"
+                "\n"
+                "Homepage:    <" PACKAGE_URL ">\n"
+                "Bug Reports: <" PACKAGE_BUGREPORT ">\n"
+        );
+}
+
+int main(int argc, char* argv[])
+{
+        idevice_t device = NULL;
+        lockdownd_client_t lockdownd = NULL;
+        afc_client_t afc = NULL;
+
+        idevice_error_t device_error = IDEVICE_E_SUCCESS;
+        lockdownd_error_t lockdownd_error = LOCKDOWN_E_SUCCESS;
+        afc_error_t afc_error = AFC_E_SUCCESS;
+
+        const char* udid = NULL;
+        int use_network = 0;
+        const char* filename_filter = NULL;
+
+        int c = 0;
+        const struct option longopts[] = {
+                { "debug", no_argument, NULL, 'd' },
+                { "help", no_argument, NULL, 'h' },
+                { "udid", required_argument, NULL, 'u' },
+                { "network", no_argument, NULL, 'n' },
+                { "version", no_argument, NULL, 'v' },
+                { "filter", required_argument, NULL, 'f' },
+                { "extract", no_argument, NULL, 'e' },
+                { "keep", no_argument, NULL, 'k' },
+                { NULL, 0, NULL, 0}
+        };
+
+#ifndef WIN32
+        signal(SIGPIPE, SIG_IGN);
+#endif
+
+        /* parse cmdline args */
+        while ((c = getopt_long(argc, argv, "dhu:nvf:ek", longopts, NULL)) != -1) {
+                switch (c) {
+                case 'd':
+                        idevice_set_debug_level(1);
+                        break;
+                case 'u':
+                        if (!*optarg) {
+                                fprintf(stderr, "ERROR: UDID argument must not be empty!\n");
+                                print_usage(argc, argv, 1);
+                                return 2;
+                        }
+                        udid = optarg;
+                        break;
+                case 'n':
+                        use_network = 1;
+                        break;
+                case 'h':
+                        print_usage(argc, argv, 0);
+                        return 0;
+                case 'v':
+                        printf("%s %s\n", TOOL_NAME, PACKAGE_VERSION);
+                        return 0;
+                case 'f':
+                        if (!*optarg) {
+                                fprintf(stderr, "ERROR: filter argument must not be empty!\n");
+                                print_usage(argc, argv, 1);
+                                return 2;
+                        }
+                        filename_filter = optarg;
+                        break;
+                case 'e':
+                        extract_raw_crash_reports = 1;
+                        break;
+                case 'k':
+                        keep_crash_reports = 1;
+                        break;
+                default:
+                        print_usage(argc, argv, 1);
+                        return 2;
+                }
+        }
+        argc -= optind;
+        argv += optind;
+
+        /* ensure a target directory was supplied */
+        if (!argv[0]) {
+                fprintf(stderr, "ERROR: missing target directory.\n");
+                print_usage(argc+optind, argv-optind, 1);
+                return 2;
+        }
+        target_directory = argv[0];
+
+        /* check if target directory exists */
+        if (!file_exists(target_directory)) {
+                fprintf(stderr, "ERROR: Directory '%s' does not exist.\n", target_directory);
+                return 1;
+        }
+
+        device_error = idevice_new_with_options(&device, udid, (use_network) ? IDEVICE_LOOKUP_NETWORK : IDEVICE_LOOKUP_USBMUX);
+        if (device_error != IDEVICE_E_SUCCESS) {
+                if (udid) {
+                        printf("No device found with udid %s.\n", udid);
+                } else {
+                        printf("No device found.\n");
+                }
+                return -1;
+        }
+
+        lockdownd_error = lockdownd_client_new_with_handshake(device, &lockdownd, TOOL_NAME);
+        if (lockdownd_error != LOCKDOWN_E_SUCCESS) {
+                fprintf(stderr, "ERROR: Could not connect to lockdownd, error code %d\n", lockdownd_error);
+                idevice_free(device);
+                return -1;
+        }
+
+        /* start crash log mover service */
+        lockdownd_service_descriptor_t service = NULL;
+        lockdownd_error = lockdownd_start_service(lockdownd, CRASH_REPORT_MOVER_SERVICE, &service);
+        if (lockdownd_error != LOCKDOWN_E_SUCCESS) {
+                fprintf(stderr, "ERROR: Could not start service %s: %s\n", CRASH_REPORT_MOVER_SERVICE, lockdownd_strerror(lockdownd_error));
+                lockdownd_client_free(lockdownd);
+                idevice_free(device);
+                return -1;
+        }
+
+        /* trigger move operation on device */
+        service_client_t svcmove = NULL;
+        service_error_t service_error = service_client_new(device, service, &svcmove);
+        lockdownd_service_descriptor_free(service);
+        service = NULL;
+        if (service_error != SERVICE_E_SUCCESS) {
+                lockdownd_client_free(lockdownd);
+                idevice_free(device);
+                return -1;
+        }
+
+        /* read "ping" message which indicates the crash logs have been moved to a safe harbor */
+        char *ping = malloc(4);
+        memset(ping, '\0', 4);
+        int attempts = 0;
+        while ((strncmp(ping, "ping", 4) != 0) && (attempts < 10)) {
+                uint32_t bytes = 0;
+                service_error = service_receive_with_timeout(svcmove, ping, 4, &bytes, 2000);
+                if (service_error == SERVICE_E_SUCCESS || service_error == SERVICE_E_TIMEOUT) {
+                        attempts++;
+                        continue;
+                }
+
+                fprintf(stderr, "ERROR: Crash logs could not be moved. Connection interrupted (%d).\n", service_error);
+                break;
+        }
+        service_client_free(svcmove);
+        free(ping);
+
+        if (device_error != IDEVICE_E_SUCCESS || attempts > 10) {
+                fprintf(stderr, "ERROR: Failed to receive ping message from crash report mover.\n");
+                lockdownd_client_free(lockdownd);
+                idevice_free(device);
+                return -1;
+        }
+
+        lockdownd_error = lockdownd_start_service(lockdownd, CRASH_REPORT_COPY_MOBILE_SERVICE, &service);
+        if (lockdownd_error != LOCKDOWN_E_SUCCESS) {
+                fprintf(stderr, "ERROR: Could not start service %s: %s\n", CRASH_REPORT_COPY_MOBILE_SERVICE, lockdownd_strerror(lockdownd_error));
+                lockdownd_client_free(lockdownd);
+                idevice_free(device);
+                return -1;
+        }
+        lockdownd_client_free(lockdownd);
+
+        afc = NULL;
+        afc_error = afc_client_new(device, service, &afc);
+        if(afc_error != AFC_E_SUCCESS) {
+                lockdownd_client_free(lockdownd);
+                idevice_free(device);
+                return -1;
+        }
+
+        if (service) {
+                lockdownd_service_descriptor_free(service);
+                service = NULL;
+        }
+
+        /* recursively copy crash reports from the device to a local directory */
+        if (afc_client_copy_and_remove_crash_reports(afc, ".", target_directory, filename_filter) < 0) {
+                fprintf(stderr, "ERROR: Failed to get crash reports from device.\n");
+                afc_client_free(afc);
+                idevice_free(device);
+                return -1;
+        }
+
+        printf("Done.\n");
+
+        afc_client_free(afc);
+        idevice_free(device);
+
+        return 0;
+}