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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
/*
* Copyright (C) 2013 Felix Fietkau <nbd@openwrt.org>
* Copyright (C) 2013 John Crispin <blogic@openwrt.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 2.1
* as published by the Free Software Foundation
*
* This program 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.
*/
#include <libubox/avl.h>
#include <libubox/avl-cmp.h>
#include "utils.h"
#include <asm-generic/setup.h>
#include <regex.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
void
__blobmsg_list_init(struct blobmsg_list *list, int offset, int len, blobmsg_list_cmp cmp)
{
avl_init(&list->avl, avl_strcmp, false, NULL);
list->node_offset = offset;
list->node_len = len;
list->cmp = cmp;
}
int
blobmsg_list_fill(struct blobmsg_list *list, void *data, int len, bool array)
{
struct avl_tree *tree = &list->avl;
struct blobmsg_list_node *node;
struct blob_attr *cur;
void *ptr;
int count = 0;
int rem = len;
__blob_for_each_attr(cur, data, rem) {
if (!blobmsg_check_attr(cur, !array))
continue;
ptr = calloc(1, list->node_len);
if (!ptr)
return -1;
node = (void *) ((char *)ptr + list->node_offset);
if (array)
node->avl.key = blobmsg_data(cur);
else
node->avl.key = blobmsg_name(cur);
node->data = cur;
if (avl_insert(tree, &node->avl)) {
free(ptr);
continue;
}
count++;
}
return count;
}
void
blobmsg_list_move(struct blobmsg_list *list, struct blobmsg_list *src)
{
struct blobmsg_list_node *node, *tmp;
void *ptr;
avl_remove_all_elements(&src->avl, node, avl, tmp) {
if (avl_insert(&list->avl, &node->avl)) {
ptr = ((char *) node - list->node_offset);
free(ptr);
}
}
}
void
blobmsg_list_free(struct blobmsg_list *list)
{
struct blobmsg_list_node *node, *tmp;
void *ptr;
avl_remove_all_elements(&list->avl, node, avl, tmp) {
ptr = ((char *) node - list->node_offset);
free(ptr);
}
}
bool
blobmsg_list_equal(struct blobmsg_list *l1, struct blobmsg_list *l2)
{
struct blobmsg_list_node *n1, *n2;
int count = l1->avl.count;
if (count != l2->avl.count)
return false;
n1 = avl_first_element(&l1->avl, n1, avl);
n2 = avl_first_element(&l2->avl, n2, avl);
while (count-- > 0) {
int len;
len = blob_len(n1->data);
if (len != blob_len(n2->data))
return false;
if (memcmp(n1->data, n2->data, len) != 0)
return false;
if (l1->cmp && !l1->cmp(n1, n2))
return false;
if (!count)
break;
n1 = avl_next_element(n1, avl);
n2 = avl_next_element(n2, avl);
}
return true;
}
char* get_cmdline_val(const char* name, char* out, int len)
{
char pattern[COMMAND_LINE_SIZE + 1];
char line[COMMAND_LINE_SIZE + 1];
char *res = NULL, *tty;
int r, fd;
regex_t pat_cmdline;
regmatch_t matches[2];
fd = open("/proc/cmdline", O_RDONLY);
if (fd < 0)
return NULL;
r = read(fd, line, COMMAND_LINE_SIZE);
if ( r <= 0 ) {
close(fd);
return NULL;
}
line[r] = '\0';
close(fd);
sprintf( pattern, "%s=([^ \n]*)", name);
regcomp(&pat_cmdline, pattern, REG_EXTENDED);
if (!regexec(&pat_cmdline, line, 2, matches, 0)) {
line[matches[1].rm_eo] = '\0';
tty = (line + matches[1].rm_so);
strncpy(out, tty, len);
tty[len-1] = '\0';
res = out;
}
regfree(&pat_cmdline);
return res;
}
|
