/*
 * This file is part of QMI-RIL.
 *
 * Copyright (C) 2010-2011 Joerie de Gram <j.de.gram@gmail.com>
 * Copyright (C) 2011-2014 Paul Kocialkowski <contact@paulk.fr>
 * Copyright (C) 2017 Wolfgang Wiedmeyer <wolfgit@wiedmeyer.de>
 *
 * QMI-RIL is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * QMI-RIL 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with QMI-RIL.  If not, see <http://www.gnu.org/licenses/>.
 */

#define LOG_TAG "RIL"
#include <utils/Log.h>

#include <utils.h>

struct list_head *list_head_alloc(struct list_head *prev, struct list_head *next,
				  const void *data)
{
	struct list_head *list;

	list = calloc(1, sizeof(struct list_head));
	list->data = data;
	list->prev = prev;
	list->next = next;

	if (prev != NULL)
		prev->next = list;
	if (next != NULL)
		next->prev = list;

	return list;
}

void list_head_free(struct list_head *list)
{
	if (list == NULL)
		return;

	if (list->next != NULL)
		list->next->prev = list->prev;
	if (list->prev != NULL)
		list->prev->next = list->next;

	memset(list, 0, sizeof(struct list_head));
	free(list);
}

int strings_array_free(char **array, size_t size)
{
	unsigned int count;
	unsigned int i;

	if (array == NULL)
		return -1;

	if (size == 0) {
		for (i = 0; array[i] != NULL; i++)
			free(array[i]);
	} else {
		count = size / sizeof(char *);
		if (count == 0)
			return -1;

		for (i = 0; i < count; i++) {
			if (array[i] != NULL)
				free(array[i]);
		}
	}

	return 0;
}

gchar *array2string(const GArray *data)
{
	gsize i, j;
	gsize new_str_length;
	char *new_str;

	if (!data)
		return g_strdup("");

	new_str_length =  2 * data->len;

	new_str = (char *) calloc(1, new_str_length);

	// print hexadecimal representation of each byte
	for (i = 0, j = 0; i < data->len; i++) {
		sprintf(&new_str[j], "%02X", g_array_index(data,
							   guint8,
							   i));
		j+=2;
	}

	return new_str;
}

size_t data2string_length(const void *data, size_t size)
{
	size_t length;

	if (data == NULL || size == 0)
		return 0;

	length = size * 2 + 1;

	return length;
}

char *data2string(const void *data, size_t size)
{
	char *string;
	size_t length;
	char *p;
	size_t i;

	if (data == NULL || size == 0)
		return NULL;

	length = data2string_length(data, size);
	if (length == 0)
		return NULL;

	string = (char *) calloc(1, length);

	p = string;

	for (i = 0; i < size; i++) {
		sprintf(p, "%02x", *((unsigned char *) data + i));
		p += 2 * sizeof(char);
	}

	return string;
}