Completely remove glib dependency.

1 files changed, 404 insertions, 88 deletions

diff --git a/src/userpref.c b/src/userpref.c
index 4aab67b..d44d5aa 100644
--- a/src/userpref.c
+++ b/src/userpref.c
@@ -19,9 +19,6 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-#include <glib.h>
-#include <glib/gstdio.h>
-#include <glib/gprintf.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -30,6 +27,15 @@
 #include <gnutls/x509.h>
 #include <gcrypt.h>
 
+#include <dirent.h>
+#include <libgen.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+#ifdef WIN32
+#include <shlobj.h>
+#endif
+
 #include "userpref.h"
 #include "debug.h"
 
@@ -41,18 +47,239 @@
 #define LIBIMOBILEDEVICE_ROOT_CERTIF "RootCertificate.pem"
 #define LIBIMOBILEDEVICE_HOST_CERTIF "HostCertificate.pem"
 
+#ifdef WIN32
+#define DIR_SEP '\\'
+#define DIR_SEP_S "\\"
+#else
+#define DIR_SEP '/'
+#define DIR_SEP_S "/"
+#endif
+
+static char __config_dir[512] = {0, };
+
+#ifdef WIN32
+static char *userpref_utf16_to_utf8(wchar_t *unistr, long len, long *items_read, long *items_written)
+{
+	if (!unistr || (len <= 0)) return NULL;
+	char *outbuf = (char*)malloc(3*(len+1));
+	int p = 0;
+	int i = 0;
+
+	wchar_t wc;
+
+	while (i < len) {
+		wc = unistr[i++];
+		if (wc >= 0x800) {
+			outbuf[p++] = (char)(0xE0 + ((wc >> 12) & 0xF));
+			outbuf[p++] = (char)(0x80 + ((wc >> 6) & 0x3F));
+			outbuf[p++] = (char)(0x80 + (wc & 0x3F));
+		} else if (wc >= 0x80) {
+			outbuf[p++] = (char)(0xC0 + ((wc >> 6) & 0x1F));
+			outbuf[p++] = (char)(0x80 + (wc & 0x3F));
+		} else {
+			outbuf[p++] = (char)(wc & 0x7F);
+		}
+	}
+	if (items_read) {
+		*items_read = i;
+	}
+	if (items_written) {
+		*items_written = p;
+	}
+	outbuf[p] = 0;
+
+	return outbuf;
+}
+#endif
+
+static const char *userpref_get_config_dir()
+{
+	if (__config_dir[0]) return __config_dir;
+#ifdef WIN32
+	wchar_t path[MAX_PATH+1];
+	HRESULT hr;
+	LPITEMIDLIST pidl = NULL;
+	BOOL b = FALSE;
+
+	hr = SHGetSpecialFolderLocation (NULL, CSIDL_LOCAL_APPDATA, &pidl);
+	if (hr == S_OK) {
+		b = SHGetPathFromIDListW (pidl, path);
+		if (b) {
+			char *cdir = userpref_utf16_to_utf8 (path, wcslen(path), NULL, NULL);
+			strcpy(__config_dir, cdir);
+			free(cdir);
+			CoTaskMemFree (pidl);
+		}
+	}
+#else
+	const char *cdir = getenv("XDG_CONFIG_HOME");
+	if (!cdir) {
+		cdir = getenv("HOME");
+		strcpy(__config_dir, cdir);
+		strcat(__config_dir, DIR_SEP_S);
+		strcat(__config_dir, ".config");
+	} else {
+		strcpy(__config_dir, cdir);
+	}
+#endif
+	strcat(__config_dir, DIR_SEP_S);
+	strcat(__config_dir, LIBIMOBILEDEVICE_CONF_DIR);
+
+	int i = strlen(__config_dir)-1;	
+	while ((i > 0) && (__config_dir[i] == DIR_SEP)) {
+		__config_dir[i--] = '\0';
+	}
+
+	return __config_dir;
+}
+
+static int mkdir_with_parents(const char *dir, int mode)
+{
+	if (!dir) return -1;
+	if (mkdir(dir, mode) == 0) {
+		return 0;
+	} else {
+		if (errno == EEXIST) return 0;	
+	}
+	int res;
+	char *parent = strdup(dir);
+	parent = dirname(parent);
+	if (parent) {
+		res = mkdir_with_parents(parent, mode);
+	} else {
+		res = -1;	
+	}
+	free(parent);
+	if (res == 0) {
+		mkdir_with_parents(dir, mode);
+	}
+	return res;
+}
+
+static int config_write(const char *cfgfile, plist_t dict)
+{
+	if (!cfgfile || !dict || (plist_get_node_type(dict) != PLIST_DICT)) {
+		return -1;
+	}
+	int res = -1;
+
+#if 1 // old style config
+	plist_t hostid = plist_dict_get_item(dict, "HostID");
+	if (hostid && (plist_get_node_type(hostid) == PLIST_STRING)) {
+		char *hostidstr = NULL;
+		plist_get_string_val(hostid, &hostidstr);
+		if (hostidstr) {
+			FILE *fd = fopen(cfgfile, "w");
+			if (fd) {
+				fprintf(fd, "\n[Global]\nHostID=%s\n", hostidstr);
+				fclose(fd);
+				res = 0;
+			}
+			free(hostidstr);
+		}
+	}
+#endif
+#if 0
+	char *xml = NULL;
+	uint32_t length = 0;
+
+	plist_to_xml(dict, &xml, &length);
+	if (!xml) {
+		return res;
+	}
+
+	FILE *fd = fopen(cfgfile, "w");
+	if (!fd) {
+		free(xml);
+		return res;
+	}
+
+	if (fwrite(xml, 1, length, fd) == length) {
+		res = 0;
+	} else {
+		fprintf(stderr, "%s: ERROR: failed to write configuration to '%s'\n", __func__, cfgfile);
+	}
+	fclose(fd);
+
+	free(xml);
+#endif
+	return res;
+}
+
+static int config_read(const char *cfgfile, plist_t *dict)
+{
+	if (!cfgfile || !dict) {
+		return -1;
+	}
+
+	int res = -1;
+	FILE *fd = fopen(cfgfile, "r+");
+	if (!fd) {
+		return -1;
+	}
+
+	fseek(fd, 0, SEEK_END);
+	unsigned long int size = ftell(fd);
+	fseek(fd, 0, SEEK_SET);
+	unsigned char *contents = NULL;
+
+	contents = malloc(size);
+	if (fread(contents, 1, size, fd) != size) {
+		free(contents);
+		fclose(fd);
+		return -1;
+	}
+	plist_t plist = NULL;
+
+	if (!memcmp(contents, "bplist00", 8)) {
+		plist_from_bin((const char*)contents, (uint32_t)size, &plist);
+		fclose(fd);
+	} else {
+		if (memchr(contents, '<', size)) {
+			plist_from_xml((const char*)contents, (uint32_t)size, &plist);
+		}
+		if (plist) {
+			fclose(fd);
+		} else {
+			// try parsing old format config file
+			char line[256];
+			fseek(fd, 0, SEEK_SET);
+			while (fgets(line, 256, fd)) {
+				size_t llen = strlen(line)-1;
+				while ((llen > 0) && ((line[llen] == '\n') || (line[llen] == '\r'))) {
+					line[llen] = '\0';
+				}
+				if (!strncmp(line, "HostID=", 7)) {
+					plist = plist_new_dict();
+					plist_dict_insert_item(plist, "HostID", plist_new_string(line+7));
+					break;
+				}
+			}
+			fclose(fd);
+			if (plist) {
+				// write new format config
+				config_write(cfgfile, plist);
+			}
+		}
+	}
+	free(contents);
+	if (plist) {
+		*dict = plist;
+		res = 0;
+	}
+	return res;
+}
 
 /**
  * Creates a freedesktop compatible configuration directory.
  */
 static void userpref_create_config_dir(void)
 {
-	gchar *config_dir = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, NULL);
-
-	if (!g_file_test(config_dir, (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)))
-		g_mkdir_with_parents(config_dir, 0755);
-
-	g_free(config_dir);
+	const char *config_path = userpref_get_config_dir();
+	struct stat st;
+	if (stat(config_path, &st) != 0) {
+		mkdir_with_parents(config_path, 0755);
+	}
 }
 
 static int get_rand(int min, int max)
@@ -94,10 +321,8 @@ static char *userpref_generate_host_id()
  */
 static int userpref_set_host_id(const char *host_id)
 {
-	GKeyFile *key_file;
-	gsize length;
-	gchar *buf, *config_file;
-	GIOChannel *file;
+	const char *config_path;
+	char *config_file;
 
 	if (!host_id)
 		return 0;
@@ -105,24 +330,34 @@ static int userpref_set_host_id(const char *host_id)
 	/* Make sure config directory exists */
 	userpref_create_config_dir();
 
+	config_path = userpref_get_config_dir();
+	config_file = (char*)malloc(strlen(config_path)+1+strlen(LIBIMOBILEDEVICE_CONF_FILE)+1);
+	strcpy(config_file, config_path);
+	strcat(config_file, DIR_SEP_S);
+	strcat(config_file, LIBIMOBILEDEVICE_CONF_FILE);
+
 	/* Now parse file to get the HostID */
-	key_file = g_key_file_new();
+	plist_t config = NULL;
+	config_read(config_file, &config);
+	if (!config) {
+		config = plist_new_dict();
+		plist_dict_insert_item(config, "HostID", plist_new_string(host_id));
+	} else {
+		plist_t n = plist_dict_get_item(config, "HostID");
+		if (n) {
+			plist_set_string_val(n, host_id);
+		} else {
+			plist_dict_insert_item(config, "HostID", plist_new_string(host_id));
+		}
+	}
 
 	/* Store in config file */
 	debug_info("setting hostID to %s", host_id);
-	g_key_file_set_value(key_file, "Global", "HostID", host_id);
-
-	/* Write config file on disk */
-	buf = g_key_file_to_data(key_file, &length, NULL);
-	config_file =
-		g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, LIBIMOBILEDEVICE_CONF_FILE, NULL);
-	file = g_io_channel_new_file(config_file, "w", NULL);
-	g_free(config_file);
-	g_io_channel_write_chars(file, buf, length, NULL, NULL);
-	g_io_channel_shutdown(file, TRUE, NULL);
-	g_io_channel_unref(file);
-
-	g_key_file_free(key_file);
+
+	config_write(config_file, config);
+	plist_free(config);
+
+	free(config_file);
 	return 1;
 }
 
@@ -135,23 +370,25 @@ static int userpref_set_host_id(const char *host_id)
  */
 void userpref_get_host_id(char **host_id)
 {
-	gchar *config_file;
-	GKeyFile *key_file;
-	gchar *loc_host_id;
+	const char *config_path;
+	char *config_file;
 
-	config_file =
-		g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, LIBIMOBILEDEVICE_CONF_FILE, NULL);
+	config_path = userpref_get_config_dir();
+	config_file = (char*)malloc(strlen(config_path)+1+strlen(LIBIMOBILEDEVICE_CONF_FILE)+1);
+	strcpy(config_file, config_path);
+	strcat(config_file, DIR_SEP_S);
+	strcat(config_file, LIBIMOBILEDEVICE_CONF_FILE);
 
 	/* now parse file to get the HostID */
-	key_file = g_key_file_new();
-	if (g_key_file_load_from_file(key_file, config_file, G_KEY_FILE_KEEP_COMMENTS, NULL)) {
-		loc_host_id = g_key_file_get_value(key_file, "Global", "HostID", NULL);
-		if (loc_host_id)
-			*host_id = strdup((char *) loc_host_id);
-		g_free(loc_host_id);
+	plist_t config = NULL;
+	if (config_read(config_file, &config) == 0) {
+		plist_t n_host_id = plist_dict_get_item(config, "HostID");
+		if (n_host_id && (plist_get_node_type(n_host_id) == PLIST_STRING)) {
+			plist_get_string_val(n_host_id, host_id);
+		}
 	}
-	g_key_file_free(key_file);
-	g_free(config_file);
+	plist_free(config);
+	free(config_file);
 
 	if (!*host_id) {
 		/* no config, generate host_id */
@@ -173,15 +410,23 @@ void userpref_get_host_id(char **host_id)
 int userpref_has_device_public_key(const char *uuid)
 {
 	int ret = 0;
-	gchar *config_file;
+	const char *config_path;
+	char *config_file;
+	struct stat st;
+
+	if (!uuid) return 0;
 
 	/* first get config file */
-	gchar *device_file = g_strconcat(uuid, ".pem", NULL);
-	config_file = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, device_file, NULL);
-	if (g_file_test(config_file, (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)))
+	config_path = userpref_get_config_dir();
+	config_file = (char*)malloc(strlen(config_path)+1+strlen(uuid)+4+1);
+	strcpy(config_file, config_path);
+	strcat(config_file, DIR_SEP_S);
+	strcat(config_file, uuid);
+	strcat(config_file, ".pem");
+
+	if ((stat(config_file, &st) == 0) && S_ISREG(st.st_mode))
 		ret = 1;
-	g_free(config_file);
-	g_free(device_file);
+	free(config_file);
 	return ret;
 }
 
@@ -202,10 +447,13 @@ int userpref_has_device_public_key(const char *uuid)
  */
 userpref_error_t userpref_get_paired_uuids(char ***list, unsigned int *count)
 {
-	GDir *config_dir;
-	gchar *config_path;
-	const gchar *dir_file;
-	GList *uuids = NULL;
+	struct slist_t {
+		char *name;
+		void *next;
+	};
+	DIR *config_dir;
+	const char *config_path;
+	struct slist_t *uuids = NULL;
 	unsigned int i;
 	unsigned int found = 0;
 
@@ -218,29 +466,44 @@ userpref_error_t userpref_get_paired_uuids(char ***list, unsigned int *count)
 		*count = 0;
 	}
 
-	config_path = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, NULL);
-
-	config_dir = g_dir_open(config_path,0,NULL);
+	config_path = userpref_get_config_dir();
+	config_dir = opendir(config_path);
 	if (config_dir) {
-		while ((dir_file = g_dir_read_name(config_dir))) {
-			if (g_str_has_suffix(dir_file, ".pem") && (strlen(dir_file) == 44)) {
-				uuids = g_list_append(uuids, g_strndup(dir_file, strlen(dir_file)-4));
+		struct dirent *entry;
+		struct slist_t *listp = uuids;
+		while ((entry = readdir(config_dir))) {
+			char *ext = strstr(entry->d_name, ".pem");
+			if (ext && ((ext - entry->d_name) == 40) && (strlen(entry->d_name) == 44)) {
+				struct slist_t *ne = (struct slist_t*)malloc(sizeof(struct slist_t));
+				ne->name = (char*)malloc(41);
+				strncpy(ne->name, entry->d_name, 40);
+				ne->name[40] = 0;
+				ne->next = NULL;
+				if (!listp) {
+					listp = ne;
+					uuids = listp;
+				} else {
+					listp->next = ne;
+					listp = listp->next;
+				}
 				found++;
 			}
 		}
-		g_dir_close(config_dir);
+		closedir(config_dir);
 	}
 	*list = (char**)malloc(sizeof(char*) * (found+1));
-	for (i = 0; i < found; i++) {
-		(*list)[i] = g_list_nth_data(uuids, i);
+	i = 0;
+	while (uuids) {
+		(*list)[i++] = uuids->name;
+		struct slist_t *old = uuids;
+		uuids = uuids->next;
+		free(old);
 	}
 	(*list)[i] = NULL;
 
 	if (count) {
 		*count = found;
 	}
-	g_list_free(uuids);
-	g_free(config_path);
 
 	return USERPREF_E_SUCCESS;
 }
@@ -266,15 +529,18 @@ userpref_error_t userpref_set_device_public_key(const char *uuid, gnutls_datum_t
 	userpref_create_config_dir();
 
 	/* build file path */
-	gchar *device_file = g_strconcat(uuid, ".pem", NULL);
-	gchar *pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, device_file, NULL);
+	const char *config_path = userpref_get_config_dir();
+	char *pem = (char*)malloc(strlen(config_path)+1+strlen(uuid)+4+1);
+	strcpy(pem, config_path);
+	strcat(pem, DIR_SEP_S);
+	strcat(pem, uuid);
+	strcat(pem, ".pem");
 
 	/* store file */
 	FILE *pFile = fopen(pem, "wb");
 	fwrite(public_key.data, 1, public_key.size, pFile);
 	fclose(pFile);
-	g_free(pem);
-	g_free(device_file);
+	free(pem);
 
 	return USERPREF_E_SUCCESS;
 }
@@ -292,14 +558,17 @@ userpref_error_t userpref_remove_device_public_key(const char *uuid)
 		return USERPREF_E_SUCCESS;
 
 	/* build file path */
-	gchar *device_file = g_strconcat(uuid, ".pem", NULL);
-	gchar *pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, device_file, NULL);
+	const char *config_path = userpref_get_config_dir();
+	char *pem = (char*)malloc(strlen(config_path)+1+strlen(uuid)+4+1);
+	strcpy(pem, config_path);
+	strcat(pem, DIR_SEP_S);
+	strcat(pem, uuid);
+	strcat(pem, ".pem");
 
 	/* remove file */
-	g_remove(pem);
+	remove(pem);
 
-	g_free(pem);
-	g_free(device_file);
+	free(pem);
 
 	return USERPREF_E_SUCCESS;
 }
@@ -314,18 +583,50 @@ userpref_error_t userpref_remove_device_public_key(const char *uuid)
  */
 static int userpref_get_file_contents(const char *file, gnutls_datum_t * data)
 {
-	gboolean success;
-	gsize size;
-	char *content;
-	gchar *filepath;
+	int success;
+	unsigned long int size = 0;
+	unsigned char *content = NULL;
+	const char *config_path;
+	char *filepath;
+	FILE *fd;
 
 	if (NULL == file || NULL == data)
 		return 0;
 
 	/* Read file */
-	filepath = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, file, NULL);
-	success = g_file_get_contents(filepath, &content, &size, NULL);
-	g_free(filepath);
+	config_path = userpref_get_config_dir();
+	filepath = (char*)malloc(strlen(config_path)+1+strlen(file)+1);
+	strcpy(filepath, config_path);
+	strcat(filepath, DIR_SEP_S);
+	strcat(filepath, file);
+
+	fd = fopen(filepath, "rb");
+	if (fd) {
+		fseek(fd, 0, SEEK_END);
+		size = ftell(fd);
+		fseek(fd, 0, SEEK_SET);
+
+		// prevent huge files
+		if (size > 0xFFFFFF) {
+			fprintf(stderr, "%s: file is too big (> 16MB). Refusing to read the contents to memory!", __func__);
+		} else {
+			size_t p = 0;
+			content = (unsigned char*)malloc(size);
+			while (!feof(fd)) {
+				p += fread(content+p, 1, size-p, fd);
+				if (ferror(fd) != 0) {
+					break;
+				}
+				if (p >= size) {
+					success = 1;
+					break;
+				}
+			}
+		}
+		fclose(fd);
+	}
+
+	free(filepath);
 
 	/* Add it to the gnutls_datnum_t structure */
 	if (success) {
@@ -549,8 +850,8 @@ userpref_error_t userpref_get_certs_as_pem(gnutls_datum_t *pem_root_cert, gnutls
 	if (userpref_get_file_contents(LIBIMOBILEDEVICE_ROOT_CERTIF, pem_root_cert) && userpref_get_file_contents(LIBIMOBILEDEVICE_HOST_CERTIF, pem_host_cert))
 		return USERPREF_E_SUCCESS;
 	else {
-		g_free(pem_root_cert->data);
-		g_free(pem_host_cert->data);
+		gnutls_free(pem_root_cert->data);
+		gnutls_free(pem_host_cert->data);
 	}
 	return USERPREF_E_INVALID_CONF;
 }
@@ -570,7 +871,8 @@ userpref_error_t userpref_get_certs_as_pem(gnutls_datum_t *pem_root_cert, gnutls
 userpref_error_t userpref_set_keys_and_certs(gnutls_datum_t * root_key, gnutls_datum_t * root_cert, gnutls_datum_t * host_key, gnutls_datum_t * host_cert)
 {
 	FILE *pFile;
-	gchar *pem;
+	char *pem;
+	const char *config_path;
 
 	if (!root_key || !host_key || !root_cert || !host_cert)
 		return USERPREF_E_INVALID_ARG;
@@ -578,30 +880,44 @@ userpref_error_t userpref_set_keys_and_certs(gnutls_datum_t * root_key, gnutls_d
 	/* Make sure config directory exists */
 	userpref_create_config_dir();
 
+	config_path = userpref_get_config_dir();
+
 	/* Now write keys and certificates to disk */
-	pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, LIBIMOBILEDEVICE_ROOT_PRIVKEY, NULL);
+	pem = (char*)malloc(strlen(config_path)+1+strlen(LIBIMOBILEDEVICE_ROOT_PRIVKEY)+1);
+	strcpy(pem, config_path);
+	strcat(pem, DIR_SEP_S);
+	strcat(pem, LIBIMOBILEDEVICE_ROOT_PRIVKEY);
 	pFile = fopen(pem, "wb");
 	fwrite(root_key->data, 1, root_key->size, pFile);
 	fclose(pFile);
-	g_free(pem);
+	free(pem);
 
-	pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, LIBIMOBILEDEVICE_HOST_PRIVKEY, NULL);
+	pem = (char*)malloc(strlen(config_path)+1+strlen(LIBIMOBILEDEVICE_HOST_PRIVKEY)+1);
+	strcpy(pem, config_path);
+	strcat(pem, DIR_SEP_S);
+	strcat(pem, LIBIMOBILEDEVICE_HOST_PRIVKEY);
 	pFile = fopen(pem, "wb");
 	fwrite(host_key->data, 1, host_key->size, pFile);
 	fclose(pFile);
-	g_free(pem);
+	free(pem);
 
-	pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, LIBIMOBILEDEVICE_ROOT_CERTIF, NULL);
+	pem = (char*)malloc(strlen(config_path)+1+strlen(LIBIMOBILEDEVICE_ROOT_CERTIF)+1);
+	strcpy(pem, config_path);
+	strcat(pem, DIR_SEP_S);
+	strcat(pem, LIBIMOBILEDEVICE_ROOT_CERTIF);
 	pFile = fopen(pem, "wb");
 	fwrite(root_cert->data, 1, root_cert->size, pFile);
 	fclose(pFile);
-	g_free(pem);
+	free(pem);
 
-	pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, LIBIMOBILEDEVICE_HOST_CERTIF, NULL);
+	pem = (char*)malloc(strlen(config_path)+1+strlen(LIBIMOBILEDEVICE_HOST_CERTIF)+1);
+	strcpy(pem, config_path);
+	strcat(pem, DIR_SEP_S);
+	strcat(pem, LIBIMOBILEDEVICE_HOST_CERTIF);
 	pFile = fopen(pem, "wb");
 	fwrite(host_cert->data, 1, host_cert->size, pFile);
 	fclose(pFile);
-	g_free(pem);
+	free(pem);
 
 	return USERPREF_E_SUCCESS;
 }