parse: remove a check that is always true (due to unsigned data type)
[project/uci.git] / blob.c
1 /*
2  * blob.c - uci <-> blobmsg conversion layer
3  * Copyright (C) 2012-2013 Felix Fietkau <nbd@openwrt.org>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU Lesser General Public License version 2.1
7  * as published by the Free Software Foundation
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU Lesser General Public License for more details.
13  */
14 #include <string.h>
15 #include <stdlib.h>
16 #include <stdio.h>
17
18 #include <libubox/blobmsg.h>
19 #include "uci.h"
20 #include "uci_blob.h"
21
22 static bool
23 uci_attr_to_blob(struct blob_buf *b, const char *str,
24                  const char *name, enum blobmsg_type type)
25 {
26         char *err;
27         int intval;
28
29         switch (type) {
30         case BLOBMSG_TYPE_STRING:
31                 blobmsg_add_string(b, name, str);
32                 break;
33         case BLOBMSG_TYPE_BOOL:
34                 if (!strcmp(str, "true") || !strcmp(str, "1"))
35                         intval = 1;
36                 else if (!strcmp(str, "false") || !strcmp(str, "0"))
37                         intval = 0;
38                 else
39                         return false;
40
41                 blobmsg_add_u8(b, name, intval);
42                 break;
43         case BLOBMSG_TYPE_INT32:
44                 intval = strtol(str, &err, 0);
45                 if (*err)
46                         return false;
47
48                 blobmsg_add_u32(b, name, intval);
49                 break;
50         default:
51                 return false;
52         }
53         return true;
54 }
55
56 static void
57 uci_array_to_blob(struct blob_buf *b, struct uci_option *o,
58                   enum blobmsg_type type)
59 {
60         struct uci_element *e;
61         char *str, *next, *word;
62
63         if (o->type == UCI_TYPE_LIST) {
64                 uci_foreach_element(&o->v.list, e) {
65                         uci_attr_to_blob(b, e->name, NULL, type);
66                 }
67                 return;
68         }
69
70         str = strdup(o->v.string);
71         next = str;
72
73         while ((word = strsep(&next, " \t")) != NULL) {
74                 if (!*word)
75                         continue;
76
77                 uci_attr_to_blob(b, word, NULL, type);
78         }
79
80         free(str);
81 }
82
83 static int
84 __uci_to_blob(struct blob_buf *b, struct uci_section *s,
85               const struct uci_blob_param_list *p)
86 {
87         const struct blobmsg_policy *attr = NULL;
88         struct uci_element *e;
89         struct uci_option *o;
90         void *array;
91         int i, ret = 0;
92
93         uci_foreach_element(&s->options, e) {
94                 for (i = 0; i < p->n_params; i++) {
95                         attr = &p->params[i];
96                         if (!strcmp(attr->name, e->name))
97                                 break;
98                 }
99
100                 if (i == p->n_params)
101                         continue;
102
103                 o = uci_to_option(e);
104
105                 if (attr->type == BLOBMSG_TYPE_ARRAY) {
106                         if (!p->info)
107                                 continue;
108
109                         array = blobmsg_open_array(b, attr->name);
110                         uci_array_to_blob(b, o, p->info[i].type);
111                         blobmsg_close_array(b, array);
112                         ret++;
113                         continue;
114                 }
115
116                 if (o->type == UCI_TYPE_LIST)
117                         continue;
118
119                 ret += uci_attr_to_blob(b, o->v.string, attr->name, attr->type);
120         }
121
122         return ret;
123 }
124
125 int
126 uci_to_blob(struct blob_buf *b, struct uci_section *s,
127             const struct uci_blob_param_list *p)
128 {
129         int ret = 0;
130         int i;
131
132         ret += __uci_to_blob(b, s, p);
133         for (i = 0; i < p->n_next; i++)
134                 ret += uci_to_blob(b, s, p->next[i]);
135
136         return ret;
137 }
138
139 bool
140 uci_blob_diff(struct blob_attr **tb1, struct blob_attr **tb2,
141               const struct uci_blob_param_list *config, unsigned long *diff)
142 {
143         bool ret = false;
144         int i;
145
146         for (i = 0; i < config->n_params; i++) {
147                 if (!tb1[i] && !tb2[i])
148                         continue;
149
150                 if (!!tb1[i] != !!tb2[i])
151                         goto mark;
152
153                 if (blob_len(tb1[i]) != blob_len(tb2[i]))
154                         goto mark;
155
156                 if (memcmp(tb1[i], tb2[i], blob_raw_len(tb1[i])) != 0)
157                         goto mark;
158
159                 continue;
160
161 mark:
162                 ret = true;
163                 if (diff)
164                         bitfield_set(diff, i);
165                 else
166                         return ret;
167         }
168
169         return ret;
170 }
171
172
173 static bool
174 __uci_blob_check_equal(struct blob_attr *c1, struct blob_attr *c2,
175                        const struct uci_blob_param_list *config)
176 {
177         struct blob_attr **tb1, **tb2;
178
179         if (!!c1 ^ !!c2)
180                 return false;
181
182         if (!c1 && !c2)
183                 return true;
184
185         tb1 = alloca(config->n_params * sizeof(struct blob_attr *));
186         blobmsg_parse(config->params, config->n_params, tb1,
187                 blob_data(c1), blob_len(c1));
188
189         tb2 = alloca(config->n_params * sizeof(struct blob_attr *));
190         blobmsg_parse(config->params, config->n_params, tb2,
191                 blob_data(c2), blob_len(c2));
192
193         return !uci_blob_diff(tb1, tb2, config, NULL);
194 }
195
196 bool
197 uci_blob_check_equal(struct blob_attr *c1, struct blob_attr *c2,
198                      const struct uci_blob_param_list *config)
199 {
200         int i;
201
202         if (!__uci_blob_check_equal(c1, c2, config))
203                 return false;
204
205         for (i = 0; i < config->n_next; i++) {
206                 if (!__uci_blob_check_equal(c1, c2, config->next[i]))
207                         return false;
208         }
209
210         return true;
211 }