Remove common code in favor of new libimobiledevice-glue

8 files changed, 70 insertions, 354 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index 328b700..8a96e46 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -6,11 +6,13 @@ AM_CFLAGS = \
         $(GLOBAL_CFLAGS) \
         $(libplist_CFLAGS) \
         $(libusb_CFLAGS) \
+        $(limd_glue_CFLAGS) \
         $(libimobiledevice_CFLAGS)
 
 AM_LDFLAGS = \
         $(libplist_LIBS) \
         $(libusb_LIBS) \
+        $(limd_glue_LIBS) \
         $(libimobiledevice_LIBS) \
         $(libpthread_LIBS)
 
diff --git a/src/client.c b/src/client.c
index 7395046..75a526d 100644
--- a/src/client.c
+++ b/src/client.c
@@ -34,10 +34,11 @@
 #include <netinet/tcp.h>
 #include <sys/un.h>
 #include <arpa/inet.h>
-#include <pthread.h>
 #include <fcntl.h>
 
 #include <plist/plist.h>
+#include <libimobiledevice-glue/collection.h>
+#include <libimobiledevice-glue/thread.h>
 
 #include "log.h"
 #include "usb.h"
@@ -75,7 +76,7 @@ struct mux_client {
 };
 
 static struct collection client_list;
-pthread_mutex_t client_list_mutex;
+mutex_t client_list_mutex;
 static uint32_t client_number = 0;
 
 #ifdef SO_PEERCRED
@@ -224,10 +225,10 @@ int client_accept(int listenfd)
         client->events = POLLIN;
         client->info = NULL;
 
-        pthread_mutex_lock(&client_list_mutex);
+        mutex_lock(&client_list_mutex);
         client->number = client_number++;
         collection_add(&client_list, client);
-        pthread_mutex_unlock(&client_list_mutex);
+        mutex_unlock(&client_list_mutex);
 
 #ifdef SO_PEERCRED
         if (log_level >= LL_INFO) {
@@ -252,7 +253,7 @@ int client_accept(int listenfd)
 void client_close(struct mux_client *client)
 {
         int found = 0;
-        pthread_mutex_lock(&client_list_mutex);
+        mutex_lock(&client_list_mutex);
         FOREACH(struct mux_client *lc, &client_list) {
                 if (client == lc) {
                         found = 1;
@@ -262,7 +263,7 @@ void client_close(struct mux_client *client)
         if (!found) {
                 // in case we get called again but client was already freed
                 usbmuxd_log(LL_DEBUG, "%s: ignoring for non-existing client %p", __func__, client);
-                pthread_mutex_unlock(&client_list_mutex);
+                mutex_unlock(&client_list_mutex);
                 return;
         }
 #ifdef SO_PEERCRED
@@ -293,17 +294,17 @@ void client_close(struct mux_client *client)
         plist_free(client->info);
 
         collection_remove(&client_list, client);
-        pthread_mutex_unlock(&client_list_mutex);
+        mutex_unlock(&client_list_mutex);
         free(client);
 }
 
 void client_get_fds(struct fdlist *list)
 {
-        pthread_mutex_lock(&client_list_mutex);
+        mutex_lock(&client_list_mutex);
         FOREACH(struct mux_client *client, &client_list) {
                 fdlist_add(list, FD_CLIENT, client->fd, client->events);
         } ENDFOREACH
-        pthread_mutex_unlock(&client_list_mutex);
+        mutex_unlock(&client_list_mutex);
 }
 
 static int output_buffer_add_message(struct mux_client *client, uint32_t tag, enum usbmuxd_msgtype msg, void *payload, int payload_length)
@@ -442,7 +443,7 @@ static int send_listener_list(struct mux_client *client, uint32_t tag)
         plist_t dict = plist_new_dict();
         plist_t listeners = plist_new_array();
 
-        pthread_mutex_lock(&client_list_mutex);
+        mutex_lock(&client_list_mutex);
         FOREACH(struct mux_client *lc, &client_list) {
                 if (lc->state == CLIENT_LISTEN) {
                         plist_t n = NULL;
@@ -489,7 +490,7 @@ static int send_listener_list(struct mux_client *client, uint32_t tag)
                         plist_array_append_item(listeners, l);
                 }
         } ENDFOREACH
-        pthread_mutex_unlock(&client_list_mutex);
+        mutex_unlock(&client_list_mutex);
 
         plist_dict_set_item(dict, "ListenerList", listeners);
         res = send_plist(client, tag, dict);
@@ -975,14 +976,14 @@ static void input_buffer_process(struct mux_client *client)
 void client_process(int fd, short events)
 {
         struct mux_client *client = NULL;
-        pthread_mutex_lock(&client_list_mutex);
+        mutex_lock(&client_list_mutex);
         FOREACH(struct mux_client *lc, &client_list) {
                 if(lc->fd == fd) {
                         client = lc;
                         break;
                 }
         } ENDFOREACH
-        pthread_mutex_unlock(&client_list_mutex);
+        mutex_unlock(&client_list_mutex);
 
         if(!client) {
                 usbmuxd_log(LL_INFO, "client_process: fd %d not found in client list", fd);
@@ -1004,45 +1005,45 @@ void client_process(int fd, short events)
 
 void client_device_add(struct device_info *dev)
 {
-        pthread_mutex_lock(&client_list_mutex);
+        mutex_lock(&client_list_mutex);
         usbmuxd_log(LL_DEBUG, "client_device_add: id %d, location 0x%x, serial %s", dev->id, dev->location, dev->serial);
         device_set_visible(dev->id);
         FOREACH(struct mux_client *client, &client_list) {
                 if(client->state == CLIENT_LISTEN)
                         send_device_add(client, dev);
         } ENDFOREACH
-        pthread_mutex_unlock(&client_list_mutex);
+        mutex_unlock(&client_list_mutex);
 }
 
 void client_device_remove(int device_id)
 {
-        pthread_mutex_lock(&client_list_mutex);
+        mutex_lock(&client_list_mutex);
         uint32_t id = device_id;
         usbmuxd_log(LL_DEBUG, "client_device_remove: id %d", device_id);
         FOREACH(struct mux_client *client, &client_list) {
                 if(client->state == CLIENT_LISTEN)
                         send_device_remove(client, id);
         } ENDFOREACH
-        pthread_mutex_unlock(&client_list_mutex);
+        mutex_unlock(&client_list_mutex);
 }
 
 void client_device_paired(int device_id)
 {
-        pthread_mutex_lock(&client_list_mutex);
+        mutex_lock(&client_list_mutex);
         uint32_t id = device_id;
         usbmuxd_log(LL_DEBUG, "client_device_paired: id %d", device_id);
         FOREACH(struct mux_client *client, &client_list) {
                 if (client->state == CLIENT_LISTEN)
                         send_device_paired(client, id);
         } ENDFOREACH
-        pthread_mutex_unlock(&client_list_mutex);
+        mutex_unlock(&client_list_mutex);
 }
 
 void client_init(void)
 {
         usbmuxd_log(LL_DEBUG, "client_init");
         collection_init(&client_list);
-        pthread_mutex_init(&client_list_mutex, NULL);
+        mutex_init(&client_list_mutex);
 }
 
 void client_shutdown(void)
@@ -1051,6 +1052,6 @@ void client_shutdown(void)
         FOREACH(struct mux_client *client, &client_list) {
                 client_close(client);
         } ENDFOREACH
-        pthread_mutex_destroy(&client_list_mutex);
+        mutex_destroy(&client_list_mutex);
         collection_free(&client_list);
 }
diff --git a/src/conf.c b/src/conf.c
index 609d246..84f4326 100644
--- a/src/conf.c
+++ b/src/conf.c
@@ -39,6 +39,8 @@
 #include <shlobj.h>
 #endif
 
+#include <libimobiledevice-glue/utils.h>
+
 #include "conf.h"
 #include "utils.h"
 #include "log.h"
diff --git a/src/device.c b/src/device.c
index aac40b1..0928021 100644
--- a/src/device.c
+++ b/src/device.c
@@ -32,8 +32,11 @@
 #include <string.h>
 #include <stdint.h>
 #include <inttypes.h>
-#include <pthread.h>
 #include <unistd.h>
+
+#include <libimobiledevice-glue/collection.h>
+#include <libimobiledevice-glue/thread.h>
+
 #include "device.h"
 #include "client.h"
 #include "preflight.h"
@@ -127,19 +130,19 @@ struct mux_device
 };
 
 static struct collection device_list;
-pthread_mutex_t device_list_mutex;
+mutex_t device_list_mutex;
 
 static struct mux_device* get_mux_device_for_id(int device_id)
 {
         struct mux_device *dev = NULL;
-        pthread_mutex_lock(&device_list_mutex);
+        mutex_lock(&device_list_mutex);
         FOREACH(struct mux_device *cdev, &device_list) {
                 if(cdev->id == device_id) {
                         dev = cdev;
                         break;
                 }
         } ENDFOREACH
-        pthread_mutex_unlock(&device_list_mutex);
+        mutex_unlock(&device_list_mutex);
 
         return dev;
 }
@@ -166,7 +169,7 @@ static int get_next_device_id(void)
 {
         while(1) {
                 int ok = 1;
-                pthread_mutex_lock(&device_list_mutex);
+                mutex_lock(&device_list_mutex);
                 FOREACH(struct mux_device *dev, &device_list) {
                         if(dev->id == next_device_id) {
                                 next_device_id++;
@@ -174,7 +177,7 @@ static int get_next_device_id(void)
                                 break;
                         }
                 } ENDFOREACH
-                pthread_mutex_unlock(&device_list_mutex);
+                mutex_unlock(&device_list_mutex);
                 if(ok)
                         return next_device_id++;
         }
@@ -464,9 +467,9 @@ static int send_tcp_ack(struct mux_connection *conn)
  */
 void device_client_process(int device_id, struct mux_client *client, short events)
 {
-        pthread_mutex_lock(&device_list_mutex);
+        mutex_lock(&device_list_mutex);
         struct mux_connection *conn = get_mux_connection(device_id, client);
-        pthread_mutex_unlock(&device_list_mutex);
+        mutex_unlock(&device_list_mutex);
         if(!conn) {
                 usbmuxd_log(LL_WARNING, "Could not find connection for device %d client %p", device_id, client);
                 return;
@@ -566,9 +569,9 @@ static void device_version_input(struct mux_device *dev, struct version_header *
         vh->minor = ntohl(vh->minor);
         if(vh->major != 2 && vh->major != 1) {
                 usbmuxd_log(LL_ERROR, "Device %d has unknown version %d.%d", dev->id, vh->major, vh->minor);
-                pthread_mutex_lock(&device_list_mutex);
+                mutex_lock(&device_list_mutex);
                 collection_remove(&device_list, dev);
-                pthread_mutex_unlock(&device_list_mutex);
+                mutex_unlock(&device_list_mutex);
                 free(dev);
                 return;
         }
@@ -726,14 +729,14 @@ static void device_tcp_input(struct mux_device *dev, struct tcphdr *th, unsigned
 void device_data_input(struct usb_device *usbdev, unsigned char *buffer, uint32_t length)
 {
         struct mux_device *dev = NULL;
-        pthread_mutex_lock(&device_list_mutex);
+        mutex_lock(&device_list_mutex);
         FOREACH(struct mux_device *tdev, &device_list) {
                 if(tdev->usbdev == usbdev) {
                         dev = tdev;
                         break;
                 }
         } ENDFOREACH
-        pthread_mutex_unlock(&device_list_mutex);
+        mutex_unlock(&device_list_mutex);
         if(!dev) {
                 usbmuxd_log(LL_WARNING, "Cannot find device entry for RX input from USB device %p on location 0x%x", usbdev, usb_get_location(usbdev));
                 return;
@@ -850,15 +853,15 @@ int device_add(struct usb_device *usbdev)
                 free(dev);
                 return res;
         }
-        pthread_mutex_lock(&device_list_mutex);
+        mutex_lock(&device_list_mutex);
         collection_add(&device_list, dev);
-        pthread_mutex_unlock(&device_list_mutex);
+        mutex_unlock(&device_list_mutex);
         return 0;
 }
 
 void device_remove(struct usb_device *usbdev)
 {
-        pthread_mutex_lock(&device_list_mutex);
+        mutex_lock(&device_list_mutex);
         FOREACH(struct mux_device *dev, &device_list) {
                 if(dev->usbdev == usbdev) {
                         usbmuxd_log(LL_NOTICE, "Removed device %d on location 0x%x", dev->id, usb_get_location(usbdev));
@@ -874,48 +877,48 @@ void device_remove(struct usb_device *usbdev)
                                 preflight_device_remove_cb(dev->preflight_cb_data);
                         }
                         collection_remove(&device_list, dev);
-                        pthread_mutex_unlock(&device_list_mutex);
+                        mutex_unlock(&device_list_mutex);
                         free(dev->pktbuf);
                         free(dev);
                         return;
                 }
         } ENDFOREACH
-        pthread_mutex_unlock(&device_list_mutex);
+        mutex_unlock(&device_list_mutex);
 
         usbmuxd_log(LL_WARNING, "Cannot find device entry while removing USB device %p on location 0x%x", usbdev, usb_get_location(usbdev));
 }
 
 void device_set_visible(int device_id)
 {
-        pthread_mutex_lock(&device_list_mutex);
+        mutex_lock(&device_list_mutex);
         FOREACH(struct mux_device *dev, &device_list) {
                 if(dev->id == device_id) {
                         dev->visible = 1;
                         break;
                 }
         } ENDFOREACH
-        pthread_mutex_unlock(&device_list_mutex);
+        mutex_unlock(&device_list_mutex);
 }
 
 void device_set_preflight_cb_data(int device_id, void* data)
 {
-        pthread_mutex_lock(&device_list_mutex);
+        mutex_lock(&device_list_mutex);
         FOREACH(struct mux_device *dev, &device_list) {
                 if(dev->id == device_id) {
                         dev->preflight_cb_data = data;
                         break;
                 }
         } ENDFOREACH
-        pthread_mutex_unlock(&device_list_mutex);
+        mutex_unlock(&device_list_mutex);
 }
 
 int device_get_count(int include_hidden)
 {
         int count = 0;
         struct collection dev_list = {NULL, 0};
-        pthread_mutex_lock(&device_list_mutex);
+        mutex_lock(&device_list_mutex);
         collection_copy(&dev_list, &device_list);
-        pthread_mutex_unlock(&device_list_mutex);
+        mutex_unlock(&device_list_mutex);
 
         FOREACH(struct mux_device *dev, &dev_list) {
                 if((dev->state == MUXDEV_ACTIVE) && (include_hidden || dev->visible))
@@ -930,9 +933,9 @@ int device_get_list(int include_hidden, struct device_info **devices)
 {
         int count = 0;
         struct collection dev_list = {NULL, 0};
-        pthread_mutex_lock(&device_list_mutex);
+        mutex_lock(&device_list_mutex);
         collection_copy(&dev_list, &device_list);
-        pthread_mutex_unlock(&device_list_mutex);
+        mutex_unlock(&device_list_mutex);
 
         *devices = malloc(sizeof(struct device_info) * dev_list.capacity);
         struct device_info *p = *devices;
@@ -957,7 +960,7 @@ int device_get_list(int include_hidden, struct device_info **devices)
 int device_get_timeout(void)
 {
         uint64_t oldest = (uint64_t)-1LL;
-        pthread_mutex_lock(&device_list_mutex);
+        mutex_lock(&device_list_mutex);
         FOREACH(struct mux_device *dev, &device_list) {
                 if(dev->state == MUXDEV_ACTIVE) {
                         FOREACH(struct mux_connection *conn, &dev->connections) {
@@ -966,7 +969,7 @@ int device_get_timeout(void)
                         } ENDFOREACH
                 }
         } ENDFOREACH
-        pthread_mutex_unlock(&device_list_mutex);
+        mutex_unlock(&device_list_mutex);
         uint64_t ct = mstime64();
         if((int64_t)oldest == -1LL)
                 return 100000; //meh
@@ -978,7 +981,7 @@ int device_get_timeout(void)
 void device_check_timeouts(void)
 {
         uint64_t ct = mstime64();
-        pthread_mutex_lock(&device_list_mutex);
+        mutex_lock(&device_list_mutex);
         FOREACH(struct mux_device *dev, &device_list) {
                 if(dev->state == MUXDEV_ACTIVE) {
                         FOREACH(struct mux_connection *conn, &dev->connections) {
@@ -991,14 +994,14 @@ void device_check_timeouts(void)
                         } ENDFOREACH
                 }
         } ENDFOREACH
-        pthread_mutex_unlock(&device_list_mutex);
+        mutex_unlock(&device_list_mutex);
 }
 
 void device_init(void)
 {
         usbmuxd_log(LL_DEBUG, "device_init");
         collection_init(&device_list);
-        pthread_mutex_init(&device_list_mutex, NULL);
+        mutex_init(&device_list_mutex);
         next_device_id = 1;
 }
 
@@ -1019,7 +1022,7 @@ void device_kill_connections(void)
 void device_shutdown(void)
 {
         usbmuxd_log(LL_DEBUG, "device_shutdown");
-        pthread_mutex_lock(&device_list_mutex);
+        mutex_lock(&device_list_mutex);
         FOREACH(struct mux_device *dev, &device_list) {
                 FOREACH(struct mux_connection *conn, &dev->connections) {
                         connection_teardown(conn);
@@ -1028,7 +1031,7 @@ void device_shutdown(void)
                 collection_remove(&device_list, dev);
                 free(dev);
         } ENDFOREACH
-        pthread_mutex_unlock(&device_list_mutex);
-        pthread_mutex_destroy(&device_list_mutex);
+        mutex_unlock(&device_list_mutex);
+        mutex_destroy(&device_list_mutex);
         collection_free(&device_list);
 }
diff --git a/src/preflight.c b/src/preflight.c
index 6a303c2..5902f5d 100644
--- a/src/preflight.c
+++ b/src/preflight.c
@@ -26,8 +26,6 @@
 #include <unistd.h>
 #include <errno.h>
 
-#include <pthread.h>
-
 #include <sys/time.h>
 
 #ifdef HAVE_LIBIMOBILEDEVICE
@@ -36,6 +34,8 @@
 #include <libimobiledevice/notification_proxy.h>
 #endif
 
+#include <libimobiledevice-glue/thread.h>
+
 #include "preflight.h"
 #include "device.h"
 #include "client.h"
@@ -389,18 +389,15 @@ void preflight_worker_device_add(struct device_info* info)
                 infocopy->serial = strdup(info->serial);
         }
 
-        pthread_t th;
-        pthread_attr_t attr;
-
-        pthread_attr_init(&attr);
-        pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-
-        int perr = pthread_create(&th, &attr, preflight_worker_handle_device_add, infocopy);
+        THREAD_T th;
+        int perr = thread_new(&th, preflight_worker_handle_device_add, infocopy);
         if (perr != 0) {
                 free((char*)infocopy->serial);
                 free(infocopy);
                 usbmuxd_log(LL_ERROR, "ERROR: failed to start preflight worker thread for device %s: %s (%d). Invoking client_device_add() directly but things might not work as expected.", info->serial, strerror(perr), perr);
                 client_device_add(info);
+        } else {
+                thread_detach(th);
         }
 #else
         client_device_add(info);
diff --git a/src/usb.c b/src/usb.c
index 9c30055..388b6f3 100644
--- a/src/usb.c
+++ b/src/usb.c
@@ -31,6 +31,8 @@
 
 #include <libusb.h>
 
+#include <libimobiledevice-glue/collection.h>
+
 #include "usb.h"
 #include "log.h"
 #include "device.h"
diff --git a/src/utils.c b/src/utils.c
index 206c684..2cc5675 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -76,254 +76,6 @@ void fdlist_reset(struct fdlist *list)
         list->count = 0;
 }
 
-#define CAPACITY_STEP 8
-
-void collection_init(struct collection *col)
-{
-        col->list = malloc(sizeof(void *) * CAPACITY_STEP);
-        memset(col->list, 0, sizeof(void *) * CAPACITY_STEP);
-        col->capacity = CAPACITY_STEP;
-}
-
-void collection_free(struct collection *col)
-{
-        free(col->list);
-        col->list = NULL;
-        col->capacity = 0;
-}
-
-void collection_add(struct collection *col, void *element)
-{
-        int i;
-        for(i=0; i<col->capacity; i++) {
-                if(!col->list[i]) {
-                        col->list[i] = element;
-                        return;
-                }
-        }
-        col->list = realloc(col->list, sizeof(void*) * (col->capacity + CAPACITY_STEP));
-        memset(&col->list[col->capacity], 0, sizeof(void *) * CAPACITY_STEP);
-        col->list[col->capacity] = element;
-        col->capacity += CAPACITY_STEP;
-}
-
-void collection_remove(struct collection *col, void *element)
-{
-        int i;
-        for(i=0; i<col->capacity; i++) {
-                if(col->list[i] == element) {
-                        col->list[i] = NULL;
-                        return;
-                }
-        }
-        util_error("collection_remove: element %p not present in collection %p (cap %d)", element, col, col->capacity);
-}
-
-int collection_count(struct collection *col)
-{
-        int i, cnt = 0;
-        for(i=0; i<col->capacity; i++) {
-                if(col->list[i])
-                        cnt++;
-        }
-        return cnt;
-}
-
-void collection_copy(struct collection *dest, struct collection *src)
-{
-        if (!dest || !src) return;
-        dest->capacity = src->capacity;
-        dest->list = malloc(sizeof(void*) * src->capacity);
-        memcpy(dest->list, src->list, sizeof(void*) * src->capacity);
-}
-
-#ifndef HAVE_STPCPY
-/**
- * Copy characters from one string into another
- *
- * @note: The strings should not overlap, as the behavior is undefined.
- *
- * @s1: The source string.
- * @s2: The destination string.
- *
- * @return a pointer to the terminating `\0' character of @s1,
- * or NULL if @s1 or @s2 is NULL.
- */
-char *stpcpy(char * s1, const char * s2)
-{
-        if (s1 == NULL || s2 == NULL)
-                return NULL;
-
-        strcpy(s1, s2);
-
-        return s1 + strlen(s2);
-}
-#endif
-
-/**
- * Concatenate strings into a newly allocated string
- *
- * @note: Specify NULL for the last string in the varargs list
- *
- * @str: The first string in the list
- * @...: Subsequent strings.  Use NULL for the last item.
- *
- * @return a newly allocated string, or NULL if @str is NULL.  This will also
- * return NULL and set errno to ENOMEM if memory is exhausted.
- */
-char *string_concat(const char *str, ...)
-{
-        size_t len;
-        va_list args;
-        char *s;
-        char *result;
-        char *dest;
-
-        if (!str)
-                return NULL;
-
-        /* Compute final length */
-
-        len = strlen(str) + 1; /* plus 1 for the null terminator */
-
-        va_start(args, str);
-        s = va_arg(args, char *);
-        while (s) {
-                len += strlen(s);
-                s = va_arg(args, char*);
-        }
-        va_end(args);
-
-        /* Concat each string */
-
-        result = malloc(len);
-        if (!result)
-                return NULL; /* errno remains set */
-
-        dest = result;
-
-        dest = stpcpy(dest, str);
-
-        va_start(args, str);
-        s = va_arg(args, char *);
-        while (s) {
-                dest = stpcpy(dest, s);
-                s = va_arg(args, char *);
-        }
-        va_end(args);
-
-        return result;
-}
-
-int buffer_read_from_filename(const char *filename, char **buffer, uint64_t *length)
-{
-        FILE *f;
-        uint64_t size;
-
-        *length = 0;
-
-        f = fopen(filename, "rb");
-        if (!f) {
-                return 0;
-        }
-
-        fseek(f, 0, SEEK_END);
-        size = ftell(f);
-        rewind(f);
-
-        if (size == 0) {
-                fclose(f);
-                return 0;
-        }
-
-        *buffer = (char*)malloc(sizeof(char)*(size+1));
-
-        if (!buffer) {
-                return 0;
-        }
-
-        int ret = 1;
-        if (fread(*buffer, sizeof(char), size, f) != size) {
-                usbmuxd_log(LL_ERROR, "%s: ERROR: couldn't read %d bytes from %s", __func__, (int)size, filename);
-                free(*buffer);
-                ret = 0;
-                errno = EIO;
-        }
-        fclose(f);
-
-        *length = size;
-        return ret;
-}
-
-int buffer_write_to_filename(const char *filename, const char *buffer, uint64_t length)
-{
-        FILE *f;
-
-        f = fopen(filename, "wb");
-        if (f) {
-                size_t written = fwrite(buffer, sizeof(char), length, f);
-                fclose(f);
-
-                if (written == length) {
-                        return 1;
-                }
-                else {
-                        // Not all data could be written.
-                        errno = EIO;
-                        return 0;
-                }
-        }
-        else {
-                // Failed to open the file, let the caller know.
-                return 0;
-        }
-}
-
-int plist_read_from_filename(plist_t *plist, const char *filename)
-{
-        char *buffer = NULL;
-        uint64_t length;
-
-        if (!filename)
-                return 0;
-
-        if (!buffer_read_from_filename(filename, &buffer, &length)) {
-                return 0;
-        }
-
-        if ((length > 8) && (memcmp(buffer, "bplist00", 8) == 0)) {
-                plist_from_bin(buffer, length, plist);
-        } else {
-                plist_from_xml(buffer, length, plist);
-        }
-
-        free(buffer);
-
-        return 1;
-}
-
-int plist_write_to_filename(plist_t plist, const char *filename, enum plist_format_t format)
-{
-        char *buffer = NULL;
-        uint32_t length;
-
-        if (!plist || !filename)
-                return 0;
-
-        if (format == PLIST_FORMAT_XML)
-                plist_to_xml(plist, &buffer, &length);
-        else if (format == PLIST_FORMAT_BINARY)
-                plist_to_bin(plist, &buffer, &length);
-        else
-                return 0;
-
-        int res  = buffer_write_to_filename(filename, buffer, length);
-
-        free(buffer);
-
-        return res;
-}
-
 #ifndef HAVE_CLOCK_GETTIME
 typedef int clockid_t;
 #define CLOCK_MONOTONIC 1
diff --git a/src/utils.h b/src/utils.h
index b5cab3f..ce3b2e0 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -43,49 +43,6 @@ void fdlist_add(struct fdlist *list, enum fdowner owner, int fd, short events);
 void fdlist_free(struct fdlist *list);
 void fdlist_reset(struct fdlist *list);
 
-struct collection {
-        void **list;
-        int capacity;
-};
-
-void collection_init(struct collection *col);
-void collection_add(struct collection *col, void *element);
-void collection_remove(struct collection *col, void *element);
-int collection_count(struct collection *col);
-void collection_free(struct collection *col);
-void collection_copy(struct collection *dest, struct collection *src);
-
-#define MERGE_(a,b) a ## _ ## b
-#define LABEL_(a,b) MERGE_(a, b)
-#define UNIQUE_VAR(a) LABEL_(a, __LINE__)
-
-#define FOREACH(var, col) \
-        do { \
-                int UNIQUE_VAR(_iter); \
-                for(UNIQUE_VAR(_iter)=0; UNIQUE_VAR(_iter)<(col)->capacity; UNIQUE_VAR(_iter)++) { \
-                        if(!(col)->list[UNIQUE_VAR(_iter)]) continue; \
-                        var = (col)->list[UNIQUE_VAR(_iter)];
-
-#define ENDFOREACH \
-                } \
-        } while(0);
-
-#ifndef HAVE_STPCPY
-char *stpcpy(char * s1, const char * s2);
-#endif
-char *string_concat(const char *str, ...);
-
-int buffer_read_from_filename(const char *filename, char **buffer, uint64_t *length);
-int buffer_write_to_filename(const char *filename, const char *buffer, uint64_t length);
-
-enum plist_format_t {
-        PLIST_FORMAT_XML,
-        PLIST_FORMAT_BINARY
-};
-
-int plist_read_from_filename(plist_t *plist, const char *filename);
-int plist_write_to_filename(plist_t plist, const char *filename, enum plist_format_t format);
-
 uint64_t mstime64(void);
 void get_tick_count(struct timeval * tv);