1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
/*
* 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;
}
|
